Métodos de solicitudes HTTP Express: Uso y comparativa
Introducción
En el desarrollo de aplicaciones web y APIs, los métodos HTTP juegan un rol fundamental al definir las acciones que se realizarán en el servidor. Express.js, un framework minimalista para Node.js, proporciona una manera simple y eficiente de manejar estos métodos en rutas específicas.
En este post, analizaremos los diferentes métodos HTTP que se utilizan en Express, su importancia y uso, con ejemplos prácticos y una tabla comparativa para entender sus diferencias.
¿Qué son los métodos de solicitudes HTTP?
Los métodos HTTP son acciones predefinidas que permiten interactuar con un servidor. Cada método tiene un propósito específico, como recuperar, enviar, actualizar o eliminar datos.
En Express.js, podemos definir rutas y asociarles métodos HTTP, como GET, POST, PUT, DELETE, entre otros, para realizar operaciones CRUD (Create, Read, Update, Delete).
Métodos HTTP más comunes en Express.js
1. GET: Recuperar datos
El método GET se utiliza para obtener datos del servidor. Es el método más común y no debería realizar operaciones que modifiquen el servidor o la base de datos.
Ejemplo en Express:
app.get('/users', (req, res) => {
res.json([{ id: 1, name: 'Juan' }, { id: 2, name: 'María' }]);
});
Uso: Obtener información de usuarios.
2. POST: Enviar datos para crear recursos
El método POST se usa para enviar datos al servidor y crear nuevos recursos, como agregar un nuevo registro en una base de datos.
Ejemplo en Express:
app.post('/users', (req, res) => {
const newUser = req.body;
res.status(201).json({ message: 'Usuario creado', user: newUser });
});
Uso: Crear un nuevo usuario.
3. PUT: Actualizar recursos
El método PUT se usa para actualizar recursos existentes en el servidor. Normalmente, reemplaza el recurso completo.
Ejemplo en Express:
app.put('/users/:id', (req, res) => {
const { id } = req.params;
const updatedData = req.body;
res.json({ message: `Usuario ${id} actualizado`, data: updatedData });
});
Uso: Actualizar toda la información de un usuario.
4. PATCH: Actualización parcial de recursos
El método PATCH se utiliza para modificar parcialmente un recurso en lugar de reemplazarlo por completo.
Ejemplo en Express:
app.patch('/users/:id', (req, res) => {
const { id } = req.params;
const partialData = req.body;
res.json({ message: `Usuario ${id} actualizado parcialmente`, data: partialData });
});
Uso: Modificar solo campos específicos de un recurso.
5. DELETE: Eliminar recursos
El método DELETE se usa para eliminar recursos del servidor.
Ejemplo en Express:
app.delete('/users/:id', (req, res) => {
const { id } = req.params;
res.json({ message: `Usuario ${id} eliminado` });
});
Uso: Eliminar un usuario específico.
Tabla Comparativa de Métodos HTTP en Express
| Método | Descripción | Idempotente | Uso Común | Ejemplo |
|---|---|---|---|---|
GET | Recuperar datos del servidor | Sí | Obtener información | app.get() |
POST | Crear un recurso en el servidor | No | Enviar datos para crear un recurso | app.post() |
PUT | Actualizar completamente un recurso | Sí | Actualizar datos completos | app.put() |
PATCH | Actualizar parcialmente un recurso | No | Actualización parcial de un recurso | app.patch() |
DELETE | Eliminar un recurso del servidor | Sí | Eliminar recursos | app.delete() |
Nota:
- Un método idempotente significa que realizar la misma operación múltiples veces producirá el mismo resultado.
POSTyPATCHno son idempotentes porque cada solicitud puede tener un resultado diferente.
Importancia de los Métodos HTTP
- Estándar y claridad: Facilitan una estructura estándar para construir aplicaciones RESTful.
- Operaciones CRUD: Permiten mapear acciones específicas, como creación, lectura, actualización y eliminación de datos.
- Optimización: Ayudan a los desarrolladores a construir aplicaciones claras y eficientes.
- Seguridad: Diferenciar métodos permite aplicar middleware y reglas específicas, como la autenticación solo en rutas de
POSToDELETE.
Ejemplo Práctico: CRUD con Express.js
Código completo:
const express = require('express');
const app = express();
app.use(express.json()); // Middleware para parsear JSON
let users = [
{ id: 1, name: 'Juan' },
{ id: 2, name: 'María' }
];
// GET: Obtener usuarios
app.get('/users', (req, res) => {
res.json(users);
});
// POST: Crear un nuevo usuario
app.post('/users', (req, res) => {
const newUser = req.body;
users.push(newUser);
res.status(201).json({ message: 'Usuario creado', user: newUser });
});
// PUT: Actualizar un usuario por ID
app.put('/users/:id', (req, res) => {
const { id } = req.params;
const updatedUser = req.body;
users = users.map(user => (user.id === parseInt(id) ? updatedUser : user));
res.json({ message: `Usuario ${id} actualizado`, user: updatedUser });
});
// DELETE: Eliminar un usuario por ID
app.delete('/users/:id', (req, res) => {
const { id } = req.params;
users = users.filter(user => user.id !== parseInt(id));
res.json({ message: `Usuario ${id} eliminado` });
});
const PORT = 3000;
app.listen(PORT, () => {
console.log(`Servidor en http://localhost:${PORT}`);
});
Conclusión
Los métodos HTTP en Express.js son la base para construir aplicaciones web robustas y APIs RESTful. Cada método cumple una función específica y permite mapear operaciones CRUD con claridad. Al comprender su uso y diferencias, puedes estructurar tus aplicaciones de manera eficiente y escalable.
Links de referencia:
