Express

img Express.js es uno de los frameworks más populares para construir aplicaciones web y APIs en Node.js. Es conocido por su simplicidad, flexibilidad y rapidez, lo que lo convierte en una herramienta ideal tanto para desarrolladores principiantes como para proyectos de gran escala.

¿Qué es Express?

Express.js es un framework minimalista para Node.js que proporciona herramientas para gestionar el enrutamiento, solicitudes HTTP, middleware y la creación de APIs.

Principales diferencias frente a otros frameworks:

2. ¿Para qué se usa?

Express se utiliza principalmente para desarrollar aplicaciones que requieren un backend basado en JavaScript.
Algunos contextos donde se aplica mejor:

3. ¿Qué puedo construir con Express?

Con Express puedes desarrollar una amplia variedad de soluciones, como:

4. ¿Cuándo es más conveniente usarlo?

Es recomendable usar Express cuando:

No es la mejor opción cuando:

Buenas prácticas recomendadas

Para escribir buen código en Express, considera lo siguiente:

Estructura del proyecto

Patrones recomendados

Otros consejos

Resumen rápido

✅ Fortalezas principales:

⚠️ Debilidades principales:

🛠️ Cuándo usarlo:

🚫 Cuándo evitarlo:

Temas

Conceptos relacionados

Antes de profundizar en Express, es importante tener claros algunos conceptos que suelen estar vinculados a su uso. Estos conceptos forman la base para entender cómo funciona y cómo integrarlo con otras tecnologías.

Node.js

Comando para iniciar un proyecto Node:

npm init -y

HTTP y sus métodos

Express se basa en el protocolo HTTP para enviar y recibir información.

Métodos más comunes:

método acción
GET Obtener datos.
POST Enviar o crear datos.
PUT Actualizar datos.
PATCH Actualizar parcialmente.
DELETE Eliminar datos.

Middleware

Funciones que se ejecutan entre la solicitud del cliente y la respuesta del servidor.
Usos comunes: autenticación, validación de datos, manejo de errores y logs.

Ejemplo básico:

app.use((req, res, next) => {
  console.log(`Método: ${req.method} - Ruta: ${req.url}`);
  next();
});

Enrutamiento

Proceso de definir endpoints o rutas que responden a solicitudes específicas.

Ejemplo básico:

app.get("/usuarios", (req, res) => {
  res.send("Lista de usuarios");
});

JSON

Variables de Entorno (.env)

Archivo donde se guardan configuraciones sensibles como credenciales, claves de API y puertos.

Ejemplo en .env:

PORT=3000
DB_URI=mongodb+srv://usuario:clave@cluster.mongodb.net

Uso en código:

import dotenv from "dotenv";
dotenv.config();
console.log(process.env.PORT);

REST y RESTful

Bases de datos

Express no incluye una base de datos integrada, pero se suele usar con:

Conexión básica con MongoDB usando Mongoose:

import mongoose from "mongoose";

mongoose
  .connect(process.env.DB_URI)
  .then(() => console.log("Base de datos conectada"))
  .catch((err) => console.error(err));

🔼 temas

Herramientas recomendadas

Estas herramientas facilitan el desarrollo, pruebas y despliegue de aplicaciones con Express:

Node.js y npm

Comandos básicos:

node index.js     # Ejecutar aplicación
npm install       # Instalar dependencias
npm run dev       # Correr script en modo desarrollo

Nodemon

Reinicia automáticamente el servidor cuando detecta cambios.

npm install nodemon --save-dev    # Instalación:
npx nodemon index.js              # Uso:

Postman o Insomnia

dotenv

Manejo de variables de entorno.

npm install dotenv     #Instalación

Morgan

Middleware para registrar información sobre solicitudes.

# Instalación:
npm install morgan

# Uso:
import morgan from "morgan";
app.use(morgan("dev"));

Helmet

Mejora la seguridad agregando cabeceras HTTP.

# Instalación:
npm install helmet

# Uso:
import helmet from "helmet";
app.use(helmet());

Cors

Controla quién puede acceder a la API desde otros dominios.

# Instalación:
npm install cors

# Uso:
import cors from "cors";
app.use(cors());

Swagger (Documentación de APIs)

Git y GitHub

Comandos básicos:

git init
git add .
git commit -m "Primer commit"
git push origin main

Vercel / Render / Railway

🔼 temas

Snippets rápidos

Servidor básico:

import express from "express";
const app = express();
app.get("/", (req, res) => res.send("¡Hola!"));
app.listen(3000, () => console.log("Servidor corriendo"));

Middleware de JSON:

app.use(express.json());

Middleware personalizado:

app.use((req, res, next) => {
  console.log(`${req.method} ${req.url}`);
  next();
});

Ruta GET con parámetro:

app.get("/usuario/:id", (req, res) => {
  res.send(`Usuario ${req.params.id}`);
});

Ruta POST para recibir datos:

app.post("/usuario", (req, res) => {
  res.json({ recibido: req.body });
});

Error handler middleware:

app.use((err, req, res, next) => {
  console.error(err.stack);
  res.status(500).send("Ocurrió un error");
});

Uso de CORS:

import cors from "cors";
app.use(cors());

Logger con Morgan:

import morgan from "morgan";
app.use(morgan("dev"));

Variables de entorno:

import dotenv from "dotenv";
dotenv.config();
console.log(process.env.PORT);

🔼 temas

Comandos

Instalar Express:

npm install express

Ejecutar servidor Node:

node index.js

Ejecutar con nodemon (reinicio automático):

npx nodemon index.js

Agregar middleware JSON:

app.use(express.json());

Definir rutas básicas:

app.get("/ruta", (req, res) => res.send("GET"));
app.post("/ruta", (req, res) => res.send("POST"));
app.put("/ruta", (req, res) => res.send("PUT"));
app.delete("/ruta", (req, res) => res.send("DELETE"));

Obtener parámetros de ruta:

req.params.id;

Obtener datos del body:

req.body;

Enviar JSON como respuesta:

res.json({ mensaje: "Hola" });

Enviar estado HTTP:

res.status(404).send("No encontrado");

Registrar middleware personalizado:

app.use((req, res, next) => {
  next();
});

Importar módulos (ESM):

import express from "express";

Importar módulos (CommonJS):

const express = require("express");

Escuchar puerto del servidor:

app.listen(3000, () => console.log("Servidor corriendo"));

🔼 temas

Conceptos Claves

🟢 Básico

1. ¿Qué es Express.js y en qué se diferencia de usar directamente el módulo HTTP nativo?

Diferencias con http nativo:

2. Crear un servidor básico y definir una ruta

import express from "express";
const app = express();

app.get("/", (req, res) => {
  res.send("Hola, mundo!");
});

app.listen(3000, () => console.log("Servidor en http://localhost:3000"));

3. ¿Qué son los middlewares?

Ejemplo típico:

app.use((req, res, next) => {
  console.log(`Petición recibida: ${req.method} ${req.url}`);
  next();
});

4. Diferencia entre app.use() y app.get()

5. Parámetros de ruta y de consulta

Ruta con parámetros

app.get("/users/:id", (req, res) => {
  res.send(`Usuario ID: ${req.params.id}`);
});

Parámetros de consulta (?name=Ana)

app.get("/search", (req, res) => {
  res.send(`Buscando: ${req.query.name}`);
});

6. Propósito de express.json() y express.urlencoded()

7. Función de next()

next() llama al siguiente middleware en la cadena.

🟡 Intermedio

8. Estructura de proyecto con Express

project/
├── controllers/             # Lógica de negocio.
│   └── userController.js
├── routes/                  # Definición de rutas.
│   └── userRoutes.js
├── middlewares/             # Validaciones, autenticación.
│   └── authMiddleware.js
├── app.js                   # Configuración de Express.
└── server.js                # Arranque del servidor.

9. Middleware global vs. a nivel de ruta

Global:

app.use((req, res, next) => {
  console.log("Middleware global");
  next();
});

Ruta específica:

app.get("/admin", authMiddleware, (req, res) => {
  res.send("Panel de admin");
});

10. Manejo de errores con middleware

app.use((err, req, res, next) => {
  console.error(err.stack);
  res.status(500).json({ error: "Error interno del servidor" });
});

11. Diferencia entre res.send(), res.json() y res.end()

12. Carga de archivos con Multer

import multer from "multer";
const upload = multer({ dest: "uploads/" });

app.post("/upload", upload.single("file"), (req, res) => {
  res.send(`Archivo subido: ${req.file.originalname}`);
});

13. Proteger rutas con autenticación

function authMiddleware(req, res, next) {
  if (req.headers.authorization === "Bearer token123") {
    next();
  } else {
    res.status(401).send("No autorizado");
  }
}

app.get("/private", authMiddleware, (req, res) => {
  res.send("Contenido privado");
});

14. Orden de ejecución en Express

🔴 Avanzado

15. Optimización para 10,000 peticiones concurrentes

Caching:

Compression:

import compression from "compression";
app.use(compression());

Balanceo de carga:

Buenas prácticas de arquitectura:

🔼 temas