La creación de aplicaciones web en el ecosistema de Node.js se simplificó bastante con el uso de Express.js, un framework minimalista y flexible permite a los desarrolladores construir aplicaciones robustas de manera rápida y eficiente. Un componente clave en el desarrollo con Express es el uso de middleware, que actúa como una capa intermedia entre la solicitud y la respuesta del servidor.
En esta guía, vamos a ver cómo utilizar Express y middleware para crear aplicaciones web desde cero, con ejemplos prácticos.
¿Qué es Express.js?
Express.js es un framework web para Node.js que ofrece herramientas esenciales para construir aplicaciones web y APIs. Es conocido por su simplicidad y flexibilidad, permitiendo crear tanto aplicaciones de una sola página como APIs RESTful complejas.
Su estructura ligera permite un desarrollo rápido y eficiente, manteniendo el control total sobre la aplicación. Express facilita tareas comunes como la gestión de rutas, el manejo de peticiones HTTP, y la integración con otros módulos de Node.js.
const express = require('express');
const app = express();
app.get('/', (req, res) => {
res.send('¡Bienvenido a mi aplicación web con Express!');
});
app.listen(3000, () => {
console.log('Servidor corriendo en http://localhost:3000');
});Este código básico configura un servidor Express que responde con un mensaje simple cuando se accede a la ruta raíz (/). Este es el primer paso para crear una aplicación web.
Conceptos básicos de middleware en Express
Un middleware es una función que se ejecuta durante el ciclo de vida de una solicitud en una aplicación Express. Tiene acceso a los objetos de solicitud (req) y respuesta (res), y a la función next(), que invoca el siguiente middleware en la cadena.
Los middlewares pueden:
➜ Ejecutar cualquier código.
➜ Modificar los objetos de solicitud y respuesta.
➜ Finalizar el ciclo de solicitud/respuesta.
➜ Invocar el siguiente middleware en la pila.
app.use((req, res, next) => {
console.log('Nueva solicitud recibida en:', req.url);
next();
});Este middleware registra cada solicitud recibida y luego pasa el control al siguiente middleware o ruta en la aplicación.
Creación de rutas y manejo de solicitudes
Express facilita la creación de rutas para manejar diferentes solicitudes HTTP (GET, POST, PUT, DELETE). Cada ruta puede tener uno o más middlewares que procesen la solicitud antes de enviar una respuesta.
app.get('/usuarios', (req, res) => {
res.send('Lista de usuarios');
});
app.post('/usuarios', (req, res) => {
res.send('Usuario creado');
});En este ejemplo, definimos rutas para manejar solicitudes GET y POST en la ruta /usuarios. Estas rutas representan acciones comunes en una aplicación web, como listar usuarios o crear uno nuevo.
Implementación de middleware: Casos de uso comunes
Los middlewares son herramientas poderosas en Express, y su implementación es crucial para tareas como la autenticación, la gestión de errores, y la manipulación de datos.
1. Autenticación: Verifica si un usuario tiene permiso para acceder a ciertas rutas.
const verificarAutenticacion = (req, res, next) => {
if (req.isAuthenticated()) {
next();
} else {
res.status(401).send('No autorizado');
}
};
app.get('/perfil', verificarAutenticacion, (req, res) => {
res.send('Bienvenido a tu perfil');
});2. Manejo de errores: Captura y gestiona errores de manera centralizada.
app.use((err, req, res, next) => {
console.error(err.stack);
res.status(500).send('Algo salió mal');
});3. Parseo de datos: Convierte el cuerpo de la solicitud en un formato manipulable.
app.use(express.json());
app.post('/api/data', (req, res) => {
console.log(req.body);
res.send('Datos recibidos');
});Propiedades clave en la creación de aplicaciones web
Durante el desarrollo de una aplicación web con Express, es importante entender y utilizar adecuadamente las propiedades disponibles en los objetos req y res. Estas propiedades permiten interactuar y manipular los datos de la solicitud y la respuesta de manera efectiva.
1. req.body: Accede al cuerpo de la solicitud, útil para datos enviados a través de formularios o JSON.
app.use(express.urlencoded({ extended: true }));
app.post('/formulario', (req, res) => {
res.send(`Formulario recibido: ${req.body.nombre}`);
});
2. req.params: Captura parámetros de la URL, ideal para rutas dinámicas.
app.get('/usuarios/:id', (req, res) => {
res.send(`Usuario ID: ${req.params.id}`);
});3. req.query: Accede a los parámetros de consulta en la URL.
app.get('/buscar', (req, res) => {
res.send(`Buscando: ${req.query.q}`);
});4. res.status(): Define el código de estado HTTP que se devolverá al cliente.
app.get('/error', (req, res) => {
res.status(404).send('Página no encontrada');
});5. res.json(): Envía una respuesta en formato JSON.
app.get('/api/usuario', (req, res) => {
res.json({ nombre: 'Juan', edad: 30 });
});Consejos para la creación de aplicaciones web eficientes
➜ Organización de código: Divide la aplicación en módulos para mejorar la mantenibilidad. Crea archivos separados para rutas, controladores, y middlewares.
➜ Manejo de errores: Implementa un middleware global para manejar errores y proporcionar respuestas coherentes.
➜ Uso de middlewares de terceros: Aprovecha middlewares como morgan para el registro de solicitudes, o helmet para mejorar la seguridad de la aplicación.
➜ Pruebas y debugging: Usa herramientas como nodemon para reiniciar automáticamente el servidor durante el desarrollo, y mocha o jest para probar la aplicación.
➜ Optimización de rendimiento: Implementa cachés, compresión de respuestas, y divide la carga en múltiples servidores si es necesario.
API RESTful de Tareas con Express.js
En el siguiente ejemplo, veamos cómo implementar las operaciones básicas de una API utilizando Express.js:
const express = require('express');
const app = express();
const port = 3000;
app.use(express.json()); // Middleware para parsear JSON en las solicitudes
// Lista de tareas simulada
let tareas = [
{ id: 1, titulo: 'Comprar leche', completado: false },
{ id: 2, titulo: 'Leer un libro', completado: true }
];
// Crear una nueva tarea (POST)
app.post('/tareas', (req, res) => {
const nuevaTarea = {
id: tareas.length + 1,
titulo: req.body.titulo,
completado: false
};
tareas.push(nuevaTarea);
res.status(201).json(nuevaTarea);
});
// Obtener todas las tareas (GET)
app.get('/tareas', (req, res) => {
res.json(tareas);
});
// Obtener una tarea específica por ID (GET)
app.get('/tareas/:id', (req, res) => {
const tarea = tareas.find(t => t.id === parseInt(req.params.id));
if (!tarea) return res.status(404).send('La tarea no fue encontrada.');
res.json(tarea);
});
// Actualizar una tarea (PUT)
app.put('/tareas/:id', (req, res) => {
const tarea = tareas.find(t => t.id === parseInt(req.params.id));
if (!tarea) return res.status(404).send('La tarea no fue encontrada.');
tarea.titulo = req.body.titulo;
tarea.completado = req.body.completado;
res.json(tarea);
});
// Eliminar una tarea (DELETE)
app.delete('/tareas/:id', (req, res) => {
const tarea = tareas.find(t => t.id === parseInt(req.params.id));
if (!tarea) return res.status(404).send('La tarea no fue encontrada.');
const index = tareas.indexOf(tarea);
tareas.splice(index, 1);
res.json(tarea);
});
app.listen(port, () => {
console.log(`Servidor corriendo en http://localhost:${port}`);
});1. Configuración del servidor: Se inicia un servidor Express en el puerto 3000.
2. Middleware express.json(): Permite que el servidor pueda interpretar los cuerpos de las solicitudes que están en formato JSON, esencial para manejar los datos en una API.
3. Simulación de datos: Se utiliza un array tareas para simular una base de datos de tareas.
4. Operaciones CRUD:
➜ Crear una tarea (POST /tareas): Agrega una nueva tarea a la lista.
➜ Obtener todas las tareas (GET /tareas): Devuelve la lista completa de tareas.
➜ Obtener una tarea específica (GET /tareas/): Devuelve una tarea basada en su ID.
➜ Actualizar una tarea (PUT /tareas/): Modifica el título o el estado de completado de una tarea.
➜ Eliminar una tarea (DELETE /tareas/): Elimina una tarea basada en su ID.
A partir de este ejemplo básico podemos entender cómo construir una API simple y funcional, para desarrollar aplicaciones más complejas.
Conceptos, propiedades y consejos útiles en el desarrollo de aplicaciones web con Express y middleware en Node.js, para programadores.