Preguntas para Entrevistas de Desarrollador Backend Junior (Node.js): Guía Completa

Introducción

Esta guía exhaustiva contiene 35 preguntas de entrevista cuidadosamente seleccionadas que cubren los fundamentos del desarrollo backend con Node.js. Estas son las preguntas que los desarrolladores backend junior realmente encuentran en las entrevistas. Cada pregunta incluye una respuesta completa, una evaluación de rareza y una calificación de dificultad basada en el análisis de cientos de entrevistas reales de las principales empresas tecnológicas y startups.

Ya sea que te estés preparando para tu primer rol de backend o haciendo la transición desde el desarrollo frontend, esta guía cubre todo, desde los fundamentos de JavaScript hasta el diseño de API, la gestión de bases de datos, las mejores prácticas de seguridad y las estrategias de implementación.

Fundamentos de JavaScript (8 preguntas)

1. Explica la diferencia entre var, let y const en JavaScript

Respuesta:

• var: Ámbito de función, elevado e inicializado con undefined, se puede redeclarar en el mismo ámbito, en gran parte obsoleto en el código moderno.
• let: Ámbito de bloque, elevado pero permanece en la Zona Muerta Temporal (TDZ) hasta la declaración, no se puede redeclarar en el mismo ámbito, se puede reasignar.
• const: Ámbito de bloque, elevado pero en TDZ, debe inicializarse en la declaración, no se puede reasignar (pero el contenido de objetos/arrays se puede mutar).

Ejemplo:

// var - ámbito de función
function ejemplo() {
  if (true) {
    var x = 1;
  }
  console.log(x); // 1 (accesible fuera del bloque)
}

// let - ámbito de bloque
if (true) {
  let y = 2;
}
console.log(y); // ReferenceError

// const - no se puede reasignar
const z = 3;
z = 4; // TypeError

const obj = { name: 'John' };
obj.name = 'Jane'; // OK - mutando la propiedad
obj = {}; // TypeError - no se puede reasignar

Mejor práctica: Utiliza const de forma predeterminada, let cuando necesites reasignar, nunca uses var en JavaScript moderno.

Rareza: Común Dificultad: Fácil

2. ¿Qué son los closures y proporciona un ejemplo práctico en Node.js?

Respuesta: Un closure se produce cuando una función interna tiene acceso a las variables del ámbito de su función externa (envolvente), incluso después de que la función externa haya regresado. La función interna "se cierra sobre" estas variables.

Ejemplo práctico de Node.js:

// Patrón de fábrica de middleware
function createAuthMiddleware(secretKey) {
  // secretKey es "cerrada sobre" por la función devuelta
  return function(req, res, next) {
    const token = req.headers.authorization;
    if (validateToken(token, secretKey)) {
      next();
    } else {
      res.status(401).json({ error: 'No autorizado' });
    }
  };
}

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

Beneficios:

• Privacidad de datos (secretKey no se puede acceder directamente)
• Fábricas de funciones
• Implementación del patrón de módulo
• Mantener el estado en operaciones asíncronas

Rareza: Común Dificultad: Media

3. Explica la palabra clave this y cómo difiere en las funciones de flecha

Respuesta: this se refiere al contexto de ejecución. Su valor depende de CÓMO se llama a la función.

Funciones regulares:

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

const greet = obj.greet;
greet(); // this = undefined (modo estricto) o global

Funciones de flecha:

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

Diferencia clave: Las funciones de flecha no tienen su propio this; lo heredan del ámbito envolvente.

Rareza: Común Dificultad: Media

4. ¿Qué son las Promesas y cómo difieren de los callbacks?

Respuesta: Una Promesa representa la eventual finalización (o fallo) de una operación asíncrona.

Patrón 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 anidados - difícil de leer
    });
  });
});

Patrón de Promesa:

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

Beneficios:

• Evita el callback hell
• Mejor manejo de errores con .catch()
• Operaciones encadenables
• Puede usar Promise.all() para operaciones paralelas

Rareza: Común Dificultad: Fácil-Media

5. ¿Qué es async/await y cómo mejora la legibilidad del código?

Respuesta: async/await es azúcar sintáctico construido sobre Promesas que hace que el código asíncrono se vea y se comporte más como código síncrono.

Ejemplo:

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

// Con async/await (más limpio)
async function fetchUserData(userId) {
  try {
    const user = await fetchUser(userId);
    const posts = await fetchPosts(user.id);
    return { user, posts };
  } catch (error) {
    console.error(error);
  }
}

Puntos clave:

• La función async siempre devuelve una Promesa
• await pausa la ejecución hasta que la Promesa se resuelva
• Usa try/catch para el manejo de errores
• Hace que las operaciones secuenciales sean más claras

Rareza: Común Dificultad: Media

6. Explica la desestructuración para objetos y arrays

Respuesta: La desestructuración extrae valores de arrays o propiedades de objetos en variables distintas.

Desestructuración de arrays:

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

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

Desestructuración de objetos:

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

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

// Renombrar variables
const { name: userName, age: userAge } = user;

// Desestructuración anidada
const { address: { street, zip } } = person;

Parámetros de función:

function createUser({ name, email, role = 'user' }) {
  // Usar parámetros desestructurados
}

Rareza: Común Dificultad: Fácil-Media

7. ¿Qué es el operador spread y los parámetros rest?

Respuesta:

Operador spread (...) - Expande iterables:

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

// Objetos (copia superficial)
const user = { name: 'Alice', age: 25 };
const updatedUser = { ...user, age: 26 }; // Actualización inmutable

// Argumentos de función
const numbers = [1, 2, 3];
Math.max(...numbers); // 3

Parámetros rest (...) - Recopila múltiples elementos:

// Parámetros de función
function sum(...numbers) {
  return numbers.reduce((a, b) => a + b, 0);
}
sum(1, 2, 3, 4); // 10

// Desestructuración de arrays
const [first, ...remaining] = [1, 2, 3, 4];
// first = 1, remaining = [2, 3, 4]

Diferencia clave: Spread expande, rest recopila.

Rareza: Común Dificultad: Fácil-Media

8. Explica los métodos comunes de array: map, filter, reduce, forEach

Respuesta:

map - Transforma cada elemento, devuelve un nuevo array:

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

filter - Conserva los elementos que coinciden con la condición:

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

reduce - Reduce a un solo 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 sin devolver un nuevo array:

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

Rareza: Común Dificultad: Fácil

Fundamentos de Node.js (7 preguntas)

9. ¿Qué es Node.js y cómo difiere de los lenguajes tradicionales del lado del servidor?

Respuesta: Node.js es un entorno de ejecución de JavaScript construido sobre el motor V8 de Chrome que permite que JavaScript se ejecute en el lado del servidor.

Diferencias clave:

• Bucle de eventos de un solo hilo: Utiliza un modelo de E/S no bloqueante frente a E/S bloqueante de múltiples hilos
• Asíncrono de forma predeterminada: Las operaciones no bloquean el hilo principal
• JavaScript en todas partes: Mismo lenguaje para frontend y backend
• Ecosistema NPM: El registro de paquetes más grande del mundo
• Ejecución rápida: El motor V8 compila JavaScript en código máquina nativo

Cuándo usar Node.js:

• Aplicaciones en tiempo real (chat, juegos)
• Servidores API
• Microservicios
• Aplicaciones de transmisión de datos
• Aplicaciones con uso intensivo de E/S

Cuándo NO usar:

• Tareas intensivas en CPU (procesamiento de imágenes, codificación de video)
• Aplicaciones que requieren cálculos complejos

Rareza: Común Dificultad: Fácil-Media

10. Explica el bucle de eventos en Node.js

Respuesta: El bucle de eventos es el mecanismo que permite a Node.js realizar operaciones de E/S no bloqueantes a pesar de ser de un solo hilo.

Cómo funciona:

1. Pila de llamadas: Ejecuta código síncrono (LIFO)
2. API de Node: Maneja operaciones asíncronas (fs, http, timers)
3. Cola de callbacks (Macrotareas): Contiene callbacks de las API de Node
4. Cola de microtareas: Contiene callbacks de Promesas (mayor prioridad)
5. Bucle de eventos: Mueve tareas de las colas a la pila de llamadas cuando la pila está vacía

Orden de ejecución:

console.log('1');

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

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

console.log('4');

// Salida: 1, 4, 3, 2
// Explicación:
// - El código síncrono (1, 4) se ejecuta primero
// - Las microtareas (Promesa) se ejecutan antes que las macrotareas
// - Las macrotareas (setTimeout) se ejecutan al final

Fases del bucle de eventos:

1. Temporizadores (setTimeout, setInterval)
2. Callbacks pendientes
3. Inactivo, preparar
4. Encuesta (obtener nuevos eventos de E/S)
5. Comprobar (callbacks de setImmediate)
6. Callbacks de cierre

Rareza: Común Dificultad: Difícil

11. ¿Cuál es la diferencia entre código bloqueante y no bloqueante?

Respuesta:

Código bloqueante - Detiene la ejecución hasta que la operación se completa:

// Lectura de archivo síncrona (bloquea)
const fs = require('fs');
const data = fs.readFileSync('file.txt', 'utf8');
console.log(data); // Espera a que se lea el archivo
console.log('Hecho'); // Se ejecuta después de que se lea el archivo

Código no bloqueante - Continúa la ejecución, maneja el resultado a través de un callback:

// Lectura de archivo asíncrona (no bloquea)
const fs = require('fs');
fs.readFile('file.txt', 'utf8', (err, data) => {
  if (err) throw err;
  console.log(data);
});
console.log('Hecho'); // Se ejecuta inmediatamente, antes de que se complete la lectura del archivo

Por qué es importante no bloquear:

• El servidor puede manejar múltiples solicitudes simultáneamente
• Mejor utilización de los recursos
• Rendimiento mejorado para operaciones de E/S
• Escalabilidad

Rareza: Común Dificultad: Fácil-Media

12. ¿Qué son los módulos de Node.js y cómo funciona el sistema de módulos?

Respuesta: Node.js utiliza el sistema de módulos CommonJS (aunque también se admiten los módulos ES).

CommonJS (require/module.exports):

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

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

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

Módulos ES (import/export):

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

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

Tipos de módulos:

• Módulos centrales: Integrados (fs, http, path)
• Módulos locales: Tus propios archivos
• Módulos de terceros: Instalados a través de npm

Caché de módulos: Los módulos se almacenan en caché después de la primera solicitud, por lo que las solicitudes posteriores devuelven la misma instancia.

Rareza: Común Dificultad: Fácil

13. Explica la diferencia entre process.nextTick() y setImmediate()

Respuesta:

process.nextTick() - Ejecuta el callback en la fase actual, antes que cualquier otra operación asíncrona:

console.log('1');

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

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

console.log('4');

// Salida: 1, 4, 2, 3
// nextTick tiene la máxima prioridad, incluso por encima de las Promesas

setImmediate() - Ejecuta el callback en la siguiente iteración del bucle de eventos:

console.log('1');

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

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

console.log('4');

// Salida: 1, 4, 3, 2 (o 1, 4, 2, 3 dependiendo del contexto)

Orden de prioridad:

1. Código síncrono
2. Callbacks de process.nextTick()
3. Callbacks de Promesa (microtareas)
4. setTimeout(0) / setImmediate() (macrotareas)

Casos de uso:

• nextTick: Asegura que el callback se ejecute antes que otras operaciones asíncronas
• setImmediate: Aplaza la ejecución a la siguiente iteración del bucle de eventos

Rareza: Poco común Dificultad: Media-Difícil

14. ¿Qué es el Objeto Global en Node.js?

Respuesta: El objeto global en Node.js es similar al objeto window en los navegadores, pero se llama global.

Propiedades globales:

// Disponible en todas partes sin requerir
console.log(__dirname); // Ruta del directorio actual
console.log(__filename); // Ruta del archivo actual
console.log(process); // Objeto de proceso
console.log(global); // Objeto global en sí

Globales comunes:

• process - Información y control del proceso
• Buffer - Manejar datos binarios
• setTimeout, setInterval, clearTimeout, clearInterval
• setImmediate, clearImmediate
• console - Salida de la consola

Nota: En los módulos ES, __dirname y __filename no están disponibles de forma predeterminada. Utiliza import.meta.url en su lugar.

Rareza: Común Dificultad: Fácil

15. ¿Cómo manejas los errores en las aplicaciones de Node.js?

Respuesta: El manejo de errores en Node.js se puede gestionar a través de múltiples enfoques:

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

try {
  const data = fs.readFileSync('file.txt', 'utf8');
} catch (error) {
  console.error('Error al leer el archivo:', error.message);
}

2. Patrón de error de callback:

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

3. Manejo de errores de Promesa:

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

4. Async/await con try-catch:

async function handleRequest() {
  try {
    const data = await fetchData();
    return data;
  } catch (error) {
    console.error('Error:', error);
    throw error; // Volver a lanzar si es necesario
  }
}

5. Manejadores de errores globales:

// Excepciones no capturadas
process.on('uncaughtException', (error) => {
  console.error('Excepción no capturada:', error);
  process.exit(1);
});

// Rechazos de promesa no manejados
process.on('unhandledRejection', (reason, promise) => {
  console.error('Rechazo no manejado:', reason);
});

6. Middleware de error de Express:

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

Rareza: Común Dificultad: Media

Express.js y frameworks web (6 preguntas)

16. ¿Qué es Express.js y cuáles son sus principales características?

Respuesta: Express.js es un framework de aplicaciones web Node.js mínimo y flexible que proporciona un conjunto robusto de características para construir aplicaciones web y móviles.

Principales características:

• Enrutamiento: Define endpoints y métodos HTTP
• Middleware: Funciones que se ejecutan durante el ciclo de solicitud-respuesta
• Motores de plantillas: Renderiza HTML dinámico (EJS, Pug, Handlebars)
• Manejo de errores: Middleware de manejo de errores centralizado
• Archivos estáticos: Sirve activos estáticos
• Análisis JSON: Análisis de cuerpo integrado para datos JSON y codificados en URL

Ejemplo básico:

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

app.use(express.json());

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

app.listen(3000, () => {
  console.log('Servidor ejecutándose en el puerto 3000');
});

Por qué Express:

• Mínimo y sin opiniones
• Gran ecosistema
• Fácil de aprender
• Sistema de middleware flexible

Rareza: Común Dificultad: Fácil

17. ¿Qué es el middleware en Express.js? Proporciona ejemplos.

Respuesta: Las funciones de middleware son funciones que tienen acceso al objeto de solicitud (req), al objeto de respuesta (res) y a la función next en el ciclo de solicitud-respuesta de la aplicación.

Tipos de middleware:

1. Middleware de nivel de aplicación:

app.use((req, res, next) => {
  console.log('Solicitud recibida:', req.method, req.path);
  next(); // Pasa el control al siguiente middleware
});

2. Middleware de nivel de ruta:

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

3. Middleware de manejo de errores:

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

4. Middleware integrado:

app.use(express.json()); // Analizar cuerpos JSON
app.use(express.urlencoded({ extended: true })); // Analizar URL-encoded
app.use(express.static('public')); // Servir archivos estáticos

5. Middleware de terceros:

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

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

Ejemplo de middleware de autenticación personalizado:

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

Rareza: Común Dificultad: Media

18. Explica el enrutamiento de Express y cómo organizar las rutas

Respuesta: El enrutamiento se refiere a cómo los endpoints (URI) de una aplicación responden a las solicitudes del cliente.

Enrutamiento 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) => {
  // Actualizar usuario
});

app.delete('/users/:id', (req, res) => {
  // Eliminar usuario
});

Parámetros de ruta:

app.get('/users/:userId/posts/:postId', (req, res) => {
  const { userId, postId } = req.params;
  // Acceder a los parámetros de la ruta
});

Parámetros de consulta:

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

Organizar rutas con 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);

Rareza: Común Dificultad: Fácil-Media

19. ¿Cómo manejas las cargas de archivos en Express?

Respuesta: Las cargas de archivos se pueden manejar utilizando middleware como multer.

Carga de archivos básica:

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

app.post('/upload', upload.single('file'), (req, res) => {
  // req.file contiene información del archivo
  res.json({ 
    filename: req.file.filename,
    originalname: req.file.originalname,
    size: req.file.size
  });
});

Múltiples archivos:

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

Configuración de almacenamiento personalizada:

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 }, // Límite de 5MB
  fileFilter: (req, file, cb) => {
    if (file.mimetype === 'image/jpeg' || file.mimetype === 'image/png') {
      cb(null, true);
    } else {
      cb(new Error('Solo se permiten JPEG y PNG'));
    }
  }
});

Rareza: Común Dificultad: Media

20. ¿Qué es CORS y cómo lo manejas en Express?

Respuesta: CORS (Cross-Origin Resource Sharing) es una característica de seguridad que permite o restringe que las páginas web realicen solicitudes a un dominio diferente al que sirve la página web.

Problema: Los navegadores bloquean las solicitudes de http://localhost:3000 a http://localhost:4000 de forma predeterminada (diferentes orígenes).

Solución con middleware cors:

const cors = require('cors');

// Permitir todos los orígenes (solo desarrollo)
app.use(cors());

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

// Múltiples orígenes
app.use(cors({
  origin: ['https://example.com', 'https://app.example.com']
}));

Encabezados CORS manuales:

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();
});

Rareza: Común Dificultad: Fácil-Media

21. ¿Cómo estructuras una aplicación grande de Express.js?

Respuesta: Organiza el código en módulos y carpetas lógicas para facilitar el mantenimiento.

Estructura recomendada:

proyecto/
├── 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

Ejemplo de separación de preocupaciones:

Controlador (maneja 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);
  }
};

Servicio (lógica de negocio):

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

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

Rutas:

// 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;

Configuración de la aplicación:

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

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

Rareza: Común Dificultad: Media

Conceptos de base de datos (5 preguntas)

22. ¿Cuál es la diferencia entre las bases de datos SQL y NoSQL?

Respuesta:

Bases de datos SQL (relacionales):

• Datos estructurados con tablas, filas, columnas
• El esquema debe definirse antes de su uso
• Cumplimiento de ACID (Atomicidad, Consistencia, Aislamiento, Durabilidad)
• Ejemplos: PostgreSQL, MySQL, SQLite
• Mejor para: Consultas complejas, transacciones, datos estructurados

Bases de datos NoSQL:

• Esquema flexible o sin esquema
• Varios modelos de datos (documento, clave-valor, grafo, columna)
• Escalado horizontal
• Ejemplos: MongoDB, Redis, Cassandra
• Mejor para: Aplicaciones a gran escala, esquemas flexibles, desarrollo rápido

Comparación:

Cuándo usar SQL:

• Consultas y relaciones complejas
• Se requiere cumplimiento de ACID
• Datos estructurados
• Transacciones financieras

Cuándo usar NoSQL:

• Desarrollo rápido
• Datos a gran escala
• Necesidades de esquema flexible
• Consultas sencillas

Rareza: Común Dificultad: Fácil-Media

23. ¿Cómo te conectas a una base de datos en Node.js? (Ejemplo de MongoDB)

Respuesta: Usando MongoDB con Mongoose como ejemplo:

Conexión básica:

const mongoose = require('mongoose');

// Cadena de conexión
const mongoURI = 'mongodb://localhost:27017/mydb';

// Conectar
mongoose.connect(mongoURI, {
  useNewUrlParser: true,
  useUnifiedTopology: true
})
.then(() => console.log('MongoDB conectado'))
.catch(err => console.error('Error de conexión:', err));

Con variables de entorno:

require('dotenv').config();

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

Eventos de conexión:

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

mongoose.connection.on('error', (err) => {
  console.error('Error de conexión de Mongoose:', err);
});

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

Definir un modelo:

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