Perguntas de Entrevista para Desenvolvedor Backend Júnior (Node.js): Guia Completo

Introdução

Este guia abrangente contém 35 perguntas de entrevista cuidadosamente selecionadas, abrangendo os fundamentos do desenvolvimento backend com Node.js. Estas são as perguntas que desenvolvedores backend júnior realmente encontram em entrevistas. Cada pergunta inclui uma resposta completa, avaliação de raridade e classificação de dificuldade com base na análise de centenas de entrevistas reais de grandes empresas de tecnologia e startups.

Esteja você se preparando para sua primeira função de backend ou fazendo a transição do desenvolvimento frontend, este guia cobre tudo, desde os fundamentos do JavaScript até o design de API, gerenciamento de banco de dados, práticas recomendadas de segurança e estratégias de implantação.

Fundamentos de JavaScript (8 Perguntas)

1. Explique a diferença entre `var`, `let` e `const` em JavaScript

Resposta:

var: Escopo de função, hoisted e inicializado com undefined, pode ser redeclarado no mesmo escopo, amplamente depreciado no código moderno
let: Escopo de bloco, hoisted, mas permanece na Zona Morta Temporária (TDZ) até a declaração, não pode ser redeclarado no mesmo escopo, pode ser reatribuído
const: Escopo de bloco, hoisted, mas na TDZ, deve ser inicializado na declaração, não pode ser reatribuído (mas o conteúdo do objeto/array pode ser mutado)

Exemplo:

// var - escopo de função
function example() {
  if (true) {
    var x = 1;
  }
  console.log(x); // 1 (acessível fora do bloco)
}

// let - escopo de bloco
if (true) {
  let y = 2;
}
console.log(y); // ReferenceError

// const - não pode reatribuir
const z = 3;
z = 4; // TypeError

const obj = { name: 'John' };
obj.name = 'Jane'; // OK - propriedade mutante
obj = {}; // TypeError - não pode reatribuir

Melhor prática: Use const por padrão, let quando precisar reatribuir, nunca use var no JavaScript moderno.

Raridade: Comum Dificuldade: Fácil

2. O que são closures e forneça um exemplo prático em Node.js?

Resposta: Um closure ocorre quando uma função interna tem acesso a variáveis do escopo da função externa (envolvente), mesmo depois que a função externa retorna. A função interna "fecha" essas variáveis.

Exemplo prático em Node.js:

// Padrão de fábrica de middleware
function createAuthMiddleware(secretKey) {
  // secretKey é "fechada" pela função retornada
  return function(req, res, next) {
    const token = req.headers.authorization;
    if (validateToken(token, secretKey)) {
      next();
    } else {
      res.status(401).json({ error: 'Não autorizado' });
    }
  };
}

// Uso
const authMiddleware = createAuthMiddleware(process.env.JWT_SECRET);
app.use('/api/protected', authMiddleware);

Benefícios:

Privacidade de dados (secretKey não pode ser acessado diretamente)
Fábricas de função
Implementação do padrão de módulo
Manutenção do estado em operações assíncronas

Raridade: Comum Dificuldade: Média

3. Explique a palavra-chave `this` e como ela difere nas arrow functions

Resposta: this se refere ao contexto de execução. Seu valor depende de COMO a função é chamada.

Funções regulares:

const obj = {
  name: "Servidor",
  greet: function() {
    console.log(this.name); // "Servidor"
  }
};
obj.greet(); // this = obj

const greet = obj.greet;
greet(); // this = undefined (modo estrito) ou global

Arrow functions:

const obj = {
  name: "Servidor",
  greet: () => {
    console.log(this.name); // undefined (escopo léxico)
  }
};
obj.greet(); // this = escopo léxico (escopo de módulo em Node.js)

Diferença chave: Arrow functions não têm seu próprio this - eles o herdam do escopo envolvente.

Raridade: Comum Dificuldade: Média

4. O que são Promises e como elas diferem dos callbacks?

Resposta: Uma Promise representa a eventual conclusão (ou falha) de uma operação assíncrona.

Padrão de callback (callback hell):

getUser(userId, (err, user) => {
  if (err) return handleError(err);
  getPosts(user.id, (err, posts) => {
    if (err) return handleError(err);
    getComments(posts[0].id, (err, comments) => {
      if (err) return handleError(err);
      // Callbacks aninhados - difícil de ler
    });
  });
});

Padrão de Promise:

getUser(userId)
  .then(user => getPosts(user.id))
  .then(posts => getComments(posts[0].id))
  .then(comments => console.log(comments))
  .catch(err => handleError(err));

Benefícios:

Evita o callback hell
Melhor tratamento de erros com .catch()
Operações encadeáveis
Pode usar Promise.all() para operações paralelas

Raridade: Comum Dificuldade: Fácil-Média

5. O que é async/await e como ele melhora a legibilidade do código?

Resposta: async/await é um açúcar sintático construído sobre Promises que faz com que o código assíncrono pareça e se comporte mais como código síncrono.

Exemplo:

// Com Promises
function fetchUserData(userId) {
  return fetchUser(userId)
    .then(user => {
      return fetchPosts(user.id)
        .then(posts => {
          return { user, posts };
        });
    })
    .catch(error => console.error(error));
}

// Com async/await (mais limpo)
async function fetchUserData(userId) {
  try {
    const user = await fetchUser(userId);
    const posts = await fetchPosts(user.id);
    return { user, posts };
  } catch (error) {
    console.error(error);
  }
}

Pontos chave:

Função async sempre retorna uma Promise
await pausa a execução até que a Promise seja resolvida
Use try/catch para tratamento de erros
Torna as operações sequenciais mais claras

Raridade: Comum Dificuldade: Média

6. Explique o destructuring para objetos e arrays

Resposta: Destructuring extrai valores de arrays ou propriedades de objetos em variáveis distintas.

Destructuring de array:

const [first, second, ...rest] = [1, 2, 3, 4, 5];
// first = 1, second = 2, rest = [3, 4, 5]

// Pular elementos
const [primary, , tertiary] = ['red', 'green', 'blue'];
// primary = 'red', tertiary = 'blue'

Destructuring de objeto:

const user = { name: 'Alice', age: 25, email: '[email protected]' };

const { name, age, city = 'NYC' } = user;
// name = 'Alice', age = 25, city = 'NYC' (valor padrão)

// Renomear variáveis
const { name: userName, age: userAge } = user;

// Destructuring aninhado
const { address: { street, zip } } = person;

Parâmetros de função:

function createUser({ name, email, role = 'user' }) {
  // Use parâmetros destruturados
}

Raridade: Comum Dificuldade: Fácil-Média

7. O que é o spread operator e rest parameters?

Resposta:

Spread operator (...) - Expande iteráveis:

// Arrays
const arr1 = [1, 2, 3];
const arr2 = [...arr1, 4, 5]; // [1, 2, 3, 4, 5]

// Objetos (shallow copy)
const user = { name: 'Alice', age: 25 };
const updatedUser = { ...user, age: 26 }; // Atualização imutável

// Argumentos de função
const numbers = [1, 2, 3];
Math.max(...numbers); // 3

Rest parameters (...) - Coleta múltiplos elementos:

// Parâmetros de função
function sum(...numbers) {
  return numbers.reduce((a, b) => a + b, 0);
}
sum(1, 2, 3, 4); // 10

// Destructuring de array
const [first, ...remaining] = [1, 2, 3, 4];
// first = 1, remaining = [2, 3, 4]

Diferença chave: Spread expande, rest coleta.

Raridade: Comum Dificuldade: Fácil-Média

8. Explique os métodos comuns de array: map, filter, reduce, forEach

Resposta:

map - Transforma cada elemento, retorna um novo array:

const doubled = [1, 2, 3].map(x => x * 2); // [2, 4, 6]

filter - Mantém os elementos que correspondem à condição:

const evens = [1, 2, 3, 4].filter(x => x % 2 === 0); // [2, 4]

reduce - Reduz a um único valor:

const sum = [1, 2, 3].reduce((acc, val) => acc + val, 0); // 6
const grouped = users.reduce((acc, user) => {
  acc[user.role] = acc[user.role] || [];
  acc[user.role].push(user);
  return acc;
}, {});

forEach - Itera sem retornar um novo array:

[1, 2, 3].forEach(item => console.log(item));

Raridade: Comum Dificuldade: Fácil

Fundamentos de Node.js (7 Perguntas)

9. O que é Node.js e como ele difere das linguagens tradicionais do lado do servidor?

Resposta: Node.js é um ambiente de tempo de execução JavaScript construído no motor V8 JavaScript do Chrome que permite que o JavaScript seja executado no lado do servidor.

Diferenças chave:

Loop de eventos de thread único: Usa modelo de E/S não bloqueante vs. E/S bloqueante multi-thread
Assíncrono por padrão: As operações não bloqueiam a thread principal
JavaScript em todos os lugares: Mesma linguagem para frontend e backend
Ecossistema NPM: Maior registro de pacotes do mundo
Execução rápida: O motor V8 compila JavaScript para código de máquina nativo

Quando usar Node.js:

Aplicações em tempo real (chat, jogos)
Servidores de API
Microsserviços
Aplicações de streaming de dados
Aplicações intensivas em E/S

Quando NÃO usar:

Tarefas intensivas em CPU (processamento de imagem, codificação de vídeo)
Aplicações que exigem cálculos complexos

Raridade: Comum Dificuldade: Fácil-Média

10. Explique o Event Loop em Node.js

Resposta: O Event Loop é o mecanismo que permite que o Node.js execute operações de E/S não bloqueantes, apesar de ser de thread único.

Como funciona:

Call Stack: Executa código síncrono (LIFO)
Node APIs: Manipula operações assíncronas (fs, http, timers)
Callback Queue (Macrotasks): Contém callbacks das Node APIs
Microtask Queue: Contém callbacks de Promise (maior prioridade)
Event Loop: Move tarefas das filas para a call stack quando a stack está vazia

Ordem de execução:

console.log('1');

setTimeout(() => console.log('2'), 0);

Promise.resolve().then(() => console.log('3'));

console.log('4');

// Saída: 1, 4, 3, 2
// Explicação:
// - Código síncrono (1, 4) é executado primeiro
// - Microtasks (Promise) são executados antes de macrotasks
// - Macrotasks (setTimeout) são executados por último

Fases do Event Loop:

Timers (setTimeout, setInterval)
Pending callbacks
Idle, prepare
Poll (busca novos eventos de E/S)
Check (callbacks de setImmediate)
Close callbacks

Raridade: Comum Dificuldade: Difícil

11. Qual é a diferença entre código blocking e non-blocking?

Resposta:

Código blocking - Interrompe a execução até que a operação seja concluída:

// Leitura síncrona de arquivo (bloqueia)
const fs = require('fs');
const data = fs.readFileSync('file.txt', 'utf8');
console.log(data); // Espera pela leitura do arquivo
console.log('Concluído'); // Executa após a leitura do arquivo

Código non-blocking - Continua a execução, manipula o resultado via callback:

// Leitura assíncrona de arquivo (não bloqueia)
const fs = require('fs');
fs.readFile('file.txt', 'utf8', (err, data) => {
  if (err) throw err;
  console.log(data);
});
console.log('Concluído'); // Executa imediatamente, antes que a leitura do arquivo seja concluída

Por que non-blocking é importante:

O servidor pode lidar com várias solicitações simultaneamente
Melhor utilização de recursos
Desempenho aprimorado para operações de E/S
Escalabilidade

Raridade: Comum Dificuldade: Fácil-Média

12. O que são módulos Node.js e como funciona o sistema de módulos?

Resposta: Node.js usa o sistema de módulos CommonJS (embora os módulos ES também sejam suportados).

CommonJS (require/module.exports):

// math.js
function add(a, b) {
  return a + b;
}

module.exports = { add };
// ou
exports.add = add;

// app.js
const { add } = require('./math');
const result = add(2, 3);

ES Modules (import/export):

// math.js
export function add(a, b) {
  return a + b;
}

// app.js
import { add } from './math.js';

Tipos de módulo:

Core modules: Embutidos (fs, http, path)
Local modules: Seus próprios arquivos
Third-party modules: Instalados via npm

Module caching: Os módulos são armazenados em cache após o primeiro require, portanto, os requires subsequentes retornam a mesma instância.

Raridade: Comum Dificuldade: Fácil

13. Explique a diferença entre `process.nextTick()` e `setImmediate()`

Resposta:

process.nextTick() - Executa o callback na fase atual, antes de qualquer outra operação assíncrona:

console.log('1');

process.nextTick(() => {
  console.log('2');
});

Promise.resolve().then(() => {
  console.log('3');
});

console.log('4');

// Saída: 1, 4, 2, 3
// nextTick tem a maior prioridade, mesmo acima de Promises

setImmediate() - Executa o callback na próxima iteração do event loop:

console.log('1');

setImmediate(() => {
  console.log('2');
});

setTimeout(() => {
  console.log('3');
}, 0);

console.log('4');

// Saída: 1, 4, 3, 2 (ou 1, 4, 2, 3 dependendo do contexto)

Ordem de prioridade:

Código síncrono
Callbacks de process.nextTick()
Callbacks de Promise (microtasks)
setTimeout(0) / setImmediate() (macrotasks)

Casos de uso:

nextTick: Garante que o callback seja executado antes de outras operações assíncronas
setImmediate: Adia a execução para a próxima iteração do event loop

Raridade: Incomum Dificuldade: Média-Difícil

14. O que é o Objeto Global em Node.js?

Resposta: O objeto global em Node.js é semelhante ao objeto window nos navegadores, mas é chamado de global.

Propriedades globais:

// Disponível em todos os lugares sem requerer
console.log(__dirname); // Caminho do diretório atual
console.log(__filename); // Caminho do arquivo atual
console.log(process); // Objeto process
console.log(global); // Objeto global em si

Globais comuns:

process - Informações e controle do processo
Buffer - Manipula dados binários
setTimeout, setInterval, clearTimeout, clearInterval
setImmediate, clearImmediate
console - Saída do console

Nota: Em módulos ES, __dirname e __filename não estão disponíveis por padrão. Use import.meta.url em vez disso.

Raridade: Comum Dificuldade: Fácil

15. Como você lida com erros em aplicações Node.js?

Resposta: O tratamento de erros em Node.js pode ser gerenciado por meio de várias abordagens:

1. Try-catch para código síncrono:

try {
  const data = fs.readFileSync('file.txt', 'utf8');
} catch (error) {
  console.error('Erro ao ler o arquivo:', error.message);
}

2. Padrão de erro de callback:

fs.readFile('file.txt', 'utf8', (err, data) => {
  if (err) {
    return console.error('Erro:', err);
  }
  console.log(data);
});

3. Tratamento de erro de Promise:

fetchData()
  .then(data => processData(data))
  .catch(error => console.error('Erro:', error));

4. Async/await com try-catch:

async function handleRequest() {
  try {
    const data = await fetchData();
    return data;
  } catch (error) {
    console.error('Erro:', error);
    throw error; // Relançar se necessário
  }
}

5. Tratadores de erro global:

// Exceções não capturadas
process.on('uncaughtException', (error) => {
  console.error('Exceção não capturada:', error);
  process.exit(1);
});

// Rejeições de promise não tratadas
process.on('unhandledRejection', (reason, promise) => {
  console.error('Rejeição não tratada:', reason);
});

6. Middleware de erro do Express:

app.use((err, req, res, next) => {
  console.error(err.stack);
  res.status(500).json({ error: 'Algo deu errado!' });
});

Raridade: Comum Dificuldade: Média

Express.js & Web Frameworks (6 Perguntas)

16. O que é Express.js e quais são suas principais características?

Resposta: Express.js é um framework de aplicação web Node.js mínimo e flexível que fornece um conjunto robusto de recursos para construir aplicações web e móveis.

Principais características:

Roteamento: Define endpoints e métodos HTTP
Middleware: Funções que são executadas durante o ciclo de solicitação-resposta
Template engines: Renderiza HTML dinâmico (EJS, Pug, Handlebars)
Tratamento de erros: Middleware de tratamento de erros centralizado
Arquivos estáticos: Serve arquivos estáticos
JSON parsing: Parsing de corpo embutido para dados JSON e URL-encoded

Exemplo básico:

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

app.use(express.json());

app.get('/', (req, res) => {
  res.json({ message: 'Olá Mundo' });
});

app.listen(3000, () => {
  console.log('Servidor rodando na porta 3000');
});

Por que Express:

Mínimo e não opinativo
Grande ecossistema
Fácil de aprender
Sistema de middleware flexível

Raridade: Comum Dificuldade: Fácil

17. O que é middleware em Express.js? Forneça exemplos.

Resposta: Funções de middleware são funções que têm acesso ao objeto de solicitação (req), objeto de resposta (res) e à função next no ciclo de solicitação-resposta da aplicação.

Tipos de middleware:

1. Middleware de nível de aplicação:

app.use((req, res, next) => {
  console.log('Solicitação recebida:', req.method, req.path);
  next(); // Passa o controle para o próximo middleware
});

2. Middleware de nível de rota:

app.get('/users', authenticateUser, (req, res) => {
  res.json({ users: [] });
});

3. Middleware de tratamento de erros:

app.use((err, req, res, next) => {
  console.error(err.stack);
  res.status(500).json({ error: err.message });
});

4. Middleware embutido:

app.use(express.json()); // Faz o parsing de corpos JSON
app.use(express.urlencoded({ extended: true })); // Faz o parsing de URL-encoded
app.use(express.static('public')); // Serve arquivos estáticos

5. Middleware de terceiros:

const cors = require('cors');
const helmet = require('helmet');

app.use(cors());
app.use(helmet());

Exemplo de middleware de autenticação personalizado:

function authenticateUser(req, res, next) {
  const token = req.headers.authorization;
  if (!token) {
    return res.status(401).json({ error: 'Nenhum token fornecido' });
  }
  // Verificar token
  req.user = decodedToken;
  next();
}

Raridade: Comum Dificuldade: Média

18. Explique o roteamento do Express e como organizar as rotas

Resposta: Roteamento se refere a como os endpoints (URIs) de uma aplicação respondem às solicitações do cliente.

Roteamento básico:

app.get('/users', (req, res) => {
  res.json({ users: [] });
});

app.post('/users', (req, res) => {
  const newUser = req.body;
  res.status(201).json(newUser);
});

app.get('/users/:id', (req, res) => {
  const userId = req.params.id;
  res.json({ user: { id: userId } });
});

app.put('/users/:id', (req, res) => {
  // Atualizar usuário
});

app.delete('/users/:id', (req, res) => {
  // Deletar usuário
});

Parâmetros de rota:

app.get('/users/:userId/posts/:postId', (req, res) => {
  const { userId, postId } = req.params;
  // Acessar parâmetros de rota
});

Parâmetros de consulta:

app.get('/search', (req, res) => {
  const { q, page, limit } = req.query;
  // ?q=nodejs&page=1&limit=10
});

Organizando rotas com Express Router:

// routes/users.js
const express = require('express');
const router = express.Router();

router.get('/', (req, res) => {
  res.json({ users: [] });
});

router.get('/:id', (req, res) => {
  res.json({ user: { id: req.params.id } });
});

module.exports = router;

// app.js
const userRoutes = require('./routes/users');
app.use('/api/users', userRoutes);

Raridade: Comum Dificuldade: Fácil-Média

19. Como você lida com uploads de arquivos no Express?

Resposta: Uploads de arquivos podem ser tratados usando middleware como multer.

Upload de arquivo básico:

const multer = require('multer');
const upload = multer({ dest: 'uploads/' });

app.post('/upload', upload.single('file'), (req, res) => {
  // req.file contém informações do arquivo
  res.json({ 
    filename: req.file.filename,
    originalname: req.file.originalname,
    size: req.file.size
  });
});

Múltiplos arquivos:

app.post('/upload-multiple', upload.array('files', 10), (req, res) => {
  // req.files é um array de arquivos
  res.json({ uploaded: req.files.length });
});

Configuração de armazenamento personalizado:

const storage = multer.diskStorage({
  destination: (req, file, cb) => {
    cb(null, 'uploads/');
  },
  filename: (req, file, cb) => {
    const uniqueSuffix = Date.now() + '-' + Math.round(Math.random() * 1E9);
    cb(null, file.fieldname + '-' + uniqueSuffix);
  }
});

const upload = multer({ 
  storage: storage,
  limits: { fileSize: 5 * 1024 * 1024 }, // Limite de 5MB
  fileFilter: (req, file, cb) => {
    if (file.mimetype === 'image/jpeg' || file.mimetype === 'image/png') {
      cb(null, true);
    } else {
      cb(new Error('Apenas JPEG e PNG são permitidos'));
    }
  }
});

Raridade: Comum Dificuldade: Média

20. O que é CORS e como você lida com isso no Express?

Resposta: CORS (Cross-Origin Resource Sharing) é um recurso de segurança que permite ou restringe que páginas da web façam solicitações para um domínio diferente daquele que serve a página da web.

Problema: Os navegadores bloqueiam solicitações de http://localhost:3000 para http://localhost:4000 por padrão (origens diferentes).

Solução com middleware cors:

const cors = require('cors');

// Permitir todas as origens (apenas para desenvolvimento)
app.use(cors());

// Configurar origens específicas
app.use(cors({
  origin: 'https://example.com',
  methods: ['GET', 'POST', 'PUT', 'DELETE'],
  allowedHeaders: ['Content-Type', 'Authorization']
}));

// Múltiplas origens
app.use(cors({
  origin: ['https://example.com', 'https://app.example.com']
}));

Headers CORS manuais:

app.use((req, res, next) => {
  res.header('Access-Control-Allow-Origin', 'https://example.com');
  res.header('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE');
  res.header('Access-Control-Allow-Headers', 'Content-Type, Authorization');
  
  if (req.method === 'OPTIONS') {
    return res.sendStatus(200);
  }
  next();
});

Raridade: Comum Dificuldade: Fácil-Média

21. Como você estrutura uma grande aplicação Express.js?

Resposta: Organize o código em módulos e pastas lógicas para facilitar a manutenção.

Estrutura recomendada:

project/
├── src/
│   ├── controllers/
│   │   └── userController.js
│   ├── models/
│   │   └── User.js
│   ├── routes/
│   │   └── userRoutes.js
│   ├── middleware/
│   │   └── auth.js
│   ├── services/
│   │   └── userService.js
│   ├── utils/
│   │   └── helpers.js
│   ├── config/
│   │   └── database.js
│   └── app.js
├── tests/
├── .env
└── package.json

Exemplo de separação de preocupações:

Controller (manipula HTTP):

// controllers/userController.js
const userService = require('../services/userService');

exports.getUsers = async (req, res, next) => {
  try {
    const users = await userService.getAllUsers();
    res.json(users);
  } catch (error) {
    next(error);
  }
};

Service (lógica de negócios):

// services/userService.js
const User = require('../models/User');

exports.getAllUsers = async () => {
  return await User.find();
};

Rotas:

// routes/userRoutes.js
const express = require('express');
const router = express.Router();
const userController = require('../controllers/userController');

router.get('/', userController.getUsers);
router.post('/', userController.createUser);

module.exports = router;

Configuração do App:

// app.js
const express = require('express');
const userRoutes = require('./routes/userRoutes');

const app = express();
app.use(express.json());
app.use('/api/users', userRoutes);

Raridade: Comum Dificuldade: Média

Conceitos de Banco de Dados (5 Perguntas)

22. Qual é a diferença entre bancos de dados SQL e NoSQL?

Resposta:

Bancos de dados SQL (Relacionais):

Dados estruturados com tabelas, linhas, colunas
O esquema deve ser definido antes do uso
Conformidade com ACID (Atomicidade, Consistência, Isolamento, Durabilidade)
Exemplos: PostgreSQL, MySQL, SQLite
Melhor para: Consultas complexas, transações, dados estruturados

Bancos de dados NoSQL:

Esquema flexível ou sem esquema
Vários modelos de dados (documento, chave-valor, gráfico, coluna)
Escalabilidade horizontal
Exemplos: MongoDB, Redis, Cassandra
Melhor para: Aplicações de grande escala, esquemas flexíveis, desenvolvimento rápido

Comparação:

Característica	SQL	NoSQL
Esquema	Fixo	Flexível
Escalabilidade	Vertical	Horizontal
ACID	Sim	Varia
Linguagem de consulta	SQL	Varia
Relacionamentos	Joins	Incorporado/Referências

Quando usar SQL:

Consultas e relacionamentos complexos
Conformidade com ACID necessária
Dados estruturados
Transações financeiras

Quando usar NoSQL:

Desenvolvimento rápido
Dados em grande escala
Necessidades de esquema flexíveis
Consultas simples

Raridade: Comum Dificuldade: Fácil-Média

23. Como você se conecta a um banco de dados em Node.js? (Exemplo MongoDB)

Resposta: Usando MongoDB com Mongoose como exemplo:

Conexão básica:

const mongoose = require('mongoose');

// String de conexão
const mongoURI = 'mongodb://localhost:27017/mydb';

// Conectar
mongoose.connect(mongoURI, {
  useNewUrlParser: true,
  useUnifiedTopology: true
})
.then(() => console.log('MongoDB conectado'))
.catch(err => console.error('Erro de conexão:', err));

Com variáveis de ambiente:

require('dotenv').config();

mongoose.connect(process.env.MONGODB_URI, {
  useNewUrlParser: true,
  useUnifiedTopology: true
});

Eventos de conexão:

mongoose.connection.on('connected', () => {
  console.log('Mongoose conectado ao MongoDB');
});

mongoose.connection.on('error', (err) => {
  console.error('Erro de conexão do Mongoose:', err);
});

mongoose.connection.on('disconnected', () => {
  console.log('Mongoose desconectado');
});

Definindo um modelo:

const userSchema = new mongoose.Schema({
  name: { type: String, required: true },
  email: { type: String, required: true, unique: true },
  age: { type: Number, min: 0 }
}, { timestamps: true });

const User = mongoose.model('User', userSchema);

Usando o modelo:

// Criar
const user = await User.create({ name: 'John', email: '[email protected]' });

// Ler
const users = await User.find();
const user = await User.findById(userId);

// Atualizar
await User

Conselhos de carreira recentes

Perguntas de Entrevista para Desenvolvedor Backend Júnior (Node.js): Guia Completo

Introdução

Fundamentos de JavaScript (8 Perguntas)

1. Explique a diferença entre `var`, `let` e `const` em JavaScript

2. O que são closures e forneça um exemplo prático em Node.js?

3. Explique a palavra-chave `this` e como ela difere nas arrow functions

4. O que são Promises e como elas diferem dos callbacks?

5. O que é async/await e como ele melhora a legibilidade do código?

6. Explique o destructuring para objetos e arrays

7. O que é o spread operator e rest parameters?

8. Explique os métodos comuns de array: map, filter, reduce, forEach

Fundamentos de Node.js (7 Perguntas)

9. O que é Node.js e como ele difere das linguagens tradicionais do lado do servidor?

10. Explique o Event Loop em Node.js

11. Qual é a diferença entre código blocking e non-blocking?

12. O que são módulos Node.js e como funciona o sistema de módulos?

13. Explique a diferença entre `process.nextTick()` e `setImmediate()`

14. O que é o Objeto Global em Node.js?

15. Como você lida com erros em aplicações Node.js?

Express.js & Web Frameworks (6 Perguntas)

16. O que é Express.js e quais são suas principais características?

17. O que é middleware em Express.js? Forneça exemplos.

18. Explique o roteamento do Express e como organizar as rotas

19. Como você lida com uploads de arquivos no Express?

20. O que é CORS e como você lida com isso no Express?

21. Como você estrutura uma grande aplicação Express.js?

Conceitos de Banco de Dados (5 Perguntas)

22. Qual é a diferença entre bancos de dados SQL e NoSQL?

23. Como você se conecta a um banco de dados em Node.js? (Exemplo MongoDB)

Dicas de carreira semanais que realmente funcionam

Dicas de carreira semanais que realmente funcionam

Posts Relacionados

Perguntas para Entrevista de Desenvolvedor Backend Júnior (Python): Guia Completo

Perguntas para Entrevista de Desenvolvedor Mobile Júnior (iOS): Guia Completo

Perguntas para Entrevista de Desenvolvedor Mobile Júnior (Android): Guia Completo

Sua Próxima Entrevista Está a Apenas um Currículo de Distância

Compartilhar esta publicação

Supere a Taxa de Rejeição de 75% do ATS

Conselhos de carreira recentes

Introdução

Fundamentos de JavaScript (8 Perguntas)

1. Explique a diferença entre var, let e const em JavaScript

2. O que são closures e forneça um exemplo prático em Node.js?

3. Explique a palavra-chave this e como ela difere nas arrow functions

4. O que são Promises e como elas diferem dos callbacks?

5. O que é async/await e como ele melhora a legibilidade do código?

6. Explique o destructuring para objetos e arrays

7. O que é o spread operator e rest parameters?

8. Explique os métodos comuns de array: map, filter, reduce, forEach

Fundamentos de Node.js (7 Perguntas)

9. O que é Node.js e como ele difere das linguagens tradicionais do lado do servidor?

10. Explique o Event Loop em Node.js

11. Qual é a diferença entre código blocking e non-blocking?

12. O que são módulos Node.js e como funciona o sistema de módulos?

13. Explique a diferença entre process.nextTick() e setImmediate()

14. O que é o Objeto Global em Node.js?

15. Como você lida com erros em aplicações Node.js?

Express.js & Web Frameworks (6 Perguntas)

16. O que é Express.js e quais são suas principais características?

17. O que é middleware em Express.js? Forneça exemplos.

18. Explique o roteamento do Express e como organizar as rotas

19. Como você lida com uploads de arquivos no Express?

20. O que é CORS e como você lida com isso no Express?

21. Como você estrutura uma grande aplicação Express.js?

Conceitos de Banco de Dados (5 Perguntas)

22. Qual é a diferença entre bancos de dados SQL e NoSQL?

23. Como você se conecta a um banco de dados em Node.js? (Exemplo MongoDB)

Dicas de carreira semanais que realmente funcionam

Dicas de carreira semanais que realmente funcionam

Posts Relacionados

Perguntas para Entrevista de Desenvolvedor Backend Júnior (Python): Guia Completo

Perguntas para Entrevista de Desenvolvedor Mobile Júnior (iOS): Guia Completo

Perguntas para Entrevista de Desenvolvedor Mobile Júnior (Android): Guia Completo

Sua Próxima Entrevista Está a Apenas um Currículo de Distância

Compartilhar esta publicação

Supere a Taxa de Rejeição de 75% do ATS

1. Explique a diferença entre `var`, `let` e `const` em JavaScript

3. Explique a palavra-chave `this` e como ela difere nas arrow functions

13. Explique a diferença entre `process.nextTick()` e `setImmediate()`