Tutorial Express: Métodos GET

Rutas básicas GET

El método GET es el fundamento del routing en Express y representa la forma más directa de crear endpoints que respondan a solicitudes HTTP GET. Cuando un navegador accede a una URL o cuando realizamos una petición para obtener datos, utilizamos este método por defecto.

En Express, definir una ruta GET requiere especificar dos elementos esenciales: la ruta o path que queremos manejar y la función callback que se ejecutará cuando se acceda a esa ruta. La sintaxis básica sigue el patrón app.get(path, callback), donde app es nuestra instancia de Express.

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

// Ruta básica en la raíz
app.get('/', (req, res) => {
  res.send('¡Bienvenido a mi aplicación Express!');
});

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

Definición de múltiples rutas

Una aplicación web típica necesita múltiples endpoints para diferentes funcionalidades. Express permite definir tantas rutas GET como necesitemos, cada una con su propio path y lógica específica:

// Página principal
app.get('/', (req, res) => {
  res.send('<h1>Página Principal</h1>');
});

// Página de contacto
app.get('/contacto', (req, res) => {
  res.send('<h1>Página de Contacto</h1>');
});

// Página de servicios
app.get('/servicios', (req, res) => {
  res.send('<h1>Nuestros Servicios</h1>');
});

// Información de la empresa
app.get('/acerca-de', (req, res) => {
  res.send('<h1>Acerca de Nosotros</h1>');
});

Rutas con estructura jerárquica

Las aplicaciones modernas organizan sus rutas de forma jerárquica utilizando barras para crear una estructura lógica. Esta organización facilita tanto el desarrollo como la navegación del usuario:

// Rutas de productos
app.get('/productos', (req, res) => {
  res.send('Lista de todos los productos');
});

app.get('/productos/electronicos', (req, res) => {
  res.send('Productos electrónicos');
});

app.get('/productos/ropa', (req, res) => {
  res.send('Productos de ropa');
});

// Rutas de usuario
app.get('/usuario/perfil', (req, res) => {
  res.send('Perfil del usuario');
});

app.get('/usuario/configuracion', (req, res) => {
  res.send('Configuración del usuario');
});

Objetos request y response

Cada función callback de una ruta recibe dos objetos fundamentales: req (request) y res (response). El objeto req contiene información sobre la solicitud HTTP entrante, mientras que res proporciona métodos para enviar la respuesta al cliente:

app.get('/informacion', (req, res) => {
  // Acceso a información de la solicitud
  const metodo = req.method;
  const url = req.url;
  const headers = req.headers;
  
  // Construcción de respuesta personalizada
  const respuesta = `
    <h2>Información de la solicitud</h2>
    <p>Método: ${metodo}</p>
    <p>URL: ${url}</p>
    <p>User-Agent: ${headers['user-agent']}</p>
  `;
  
  res.send(respuesta);
});

Métodos de respuesta básicos

Express proporciona varios métodos de respuesta que determinan cómo se envían los datos al cliente. El método res.send() es el más versátil y detecta automáticamente el tipo de contenido:

// Envío de texto plano
app.get('/texto', (req, res) => {
  res.send('Este es un texto simple');
});

// Envío de HTML
app.get('/html', (req, res) => {
  res.send('<h1>Contenido HTML</h1><p>Párrafo de ejemplo</p>');
});

// Envío de números
app.get('/numero', (req, res) => {
  res.send(42);
});

// Envío de arrays
app.get('/lista', (req, res) => {
  res.send(['manzana', 'naranja', 'plátano']);
});

Códigos de estado HTTP

Aunque res.send() establece automáticamente el código de estado 200 (OK), podemos personalizar el código de estado según la situación específica utilizando res.status():

app.get('/exito', (req, res) => {
  res.status(200).send('Operación exitosa');
});

app.get('/no-encontrado', (req, res) => {
  res.status(404).send('Recurso no encontrado');
});

app.get('/error-servidor', (req, res) => {
  res.status(500).send('Error interno del servidor');
});

app.get('/creado', (req, res) => {
  res.status(201).send('Recurso creado exitosamente');
});

Rutas con patrones especiales

Express permite definir rutas que coincidan con patrones específicos utilizando caracteres especiales. El asterisco (*) actúa como comodín para capturar cualquier secuencia de caracteres:

// Coincide con cualquier ruta que comience con /archivos/
app.get('/archivos/*', (req, res) => {
  res.send(`Accediendo a archivo: ${req.url}`);
});

// Coincide con rutas que terminen en .txt
app.get('*.txt', (req, res) => {
  res.send('Archivo de texto solicitado');
});

// Ruta que captura todo lo que no coincida con otras rutas
app.get('*', (req, res) => {
  res.status(404).send('Página no encontrada');
});

La flexibilidad del routing en Express permite crear aplicaciones web robustas y bien organizadas. Cada ruta GET actúa como un punto de entrada específico que puede manejar diferentes tipos de contenido y respuestas, estableciendo la base para construir APIs y aplicaciones web completas.

Respuestas JSON

El formato JSON (JavaScript Object Notation) se ha convertido en el estándar de facto para el intercambio de datos en aplicaciones web modernas. Express proporciona métodos específicos para trabajar con JSON de manera eficiente, facilitando la creación de APIs que comunican datos estructurados entre el servidor y el cliente.

El método res.json()

Express incluye el método res.json() diseñado específicamente para enviar respuestas en formato JSON. Este método se encarga automáticamente de establecer el header Content-Type como application/json y serializar los datos JavaScript a formato JSON:

app.get('/usuario', (req, res) => {
  const usuario = {
    id: 1,
    nombre: 'Ana García',
    email: 'ana@ejemplo.com',
    activo: true
  };
  
  res.json(usuario);
});

Respuestas con arrays de datos

Las colecciones de datos son comunes en las APIs, y res.json() maneja arrays de objetos de forma natural. Esto resulta especialmente útil para endpoints que devuelven listas de elementos:

app.get('/productos', (req, res) => {
  const productos = [
    {
      id: 1,
      nombre: 'Laptop',
      precio: 899.99,
      categoria: 'Electrónicos'
    },
    {
      id: 2,
      nombre: 'Smartphone',
      precio: 599.99,
      categoria: 'Electrónicos'
    },
    {
      id: 3,
      nombre: 'Auriculares',
      precio: 149.99,
      categoria: 'Accesorios'
    }
  ];
  
  res.json(productos);
});

Estructuras de respuesta estandarizadas

Una práctica recomendada consiste en estandarizar la estructura de las respuestas JSON para mantener consistencia en toda la API. Esto facilita el consumo de los datos por parte de las aplicaciones cliente:

app.get('/estadisticas', (req, res) => {
  const respuesta = {
    exito: true,
    mensaje: 'Estadísticas obtenidas correctamente',
    datos: {
      usuariosActivos: 1250,
      ventasHoy: 45,
      ingresosMes: 15750.50
    },
    timestamp: new Date().toISOString()
  };
  
  res.json(respuesta);
});

Combinación de códigos de estado con JSON

Los códigos de estado HTTP cobran especial importancia en las APIs JSON, ya que comunican el resultado de la operación de forma estándar. Express permite combinar códigos de estado personalizados con respuestas JSON:

app.get('/perfil', (req, res) => {
  // Simulamos que el usuario no existe
  const usuarioEncontrado = false;
  
  if (!usuarioEncontrado) {
    return res.status(404).json({
      error: true,
      mensaje: 'Usuario no encontrado',
      codigo: 'USER_NOT_FOUND'
    });
  }
  
  // Si el usuario existe
  res.status(200).json({
    id: 123,
    nombre: 'Carlos Ruiz',
    ultimoAcceso: '2024-01-15T10:30:00Z'
  });
});

Respuestas JSON con datos anidados

Las aplicaciones modernas frecuentemente requieren estructuras de datos complejas con objetos anidados y relaciones entre entidades. Express maneja estas estructuras sin problemas:

app.get('/pedido', (req, res) => {
  const pedido = {
    id: 'PED-2024-001',
    fecha: '2024-01-15',
    cliente: {
      id: 456,
      nombre: 'María López',
      direccion: {
        calle: 'Gran Vía 123',
        ciudad: 'Madrid',
        codigoPostal: '28013'
      }
    },
    items: [
      {
        producto: 'Camiseta',
        cantidad: 2,
        precioUnitario: 25.99
      },
      {
        producto: 'Pantalón',
        cantidad: 1,
        precioUnitario: 45.50
      }
    ],
    total: 97.48
  };
  
  res.json(pedido);
});

Manejo de tipos de datos especiales

JavaScript incluye tipos de datos que requieren consideración especial al convertirse a JSON. Express maneja automáticamente la mayoría de casos, pero es importante entender cómo se comportan ciertos tipos:

app.get('/datos-especiales', (req, res) => {
  const datos = {
    fecha: new Date(),           // Se convierte a string ISO
    numero: 42,                  // Se mantiene como número
    decimal: 3.14159,           // Se mantiene como decimal
    booleano: true,             // Se mantiene como boolean
    nulo: null,                 // Se mantiene como null
    indefinido: undefined,      // Se omite del JSON final
    funcion: () => 'test'       // Se omite del JSON final
  };
  
  res.json(datos);
});

APIs de configuración y metadatos

Las respuestas JSON resultan ideales para endpoints de configuración que proporcionan metadatos o información del sistema a las aplicaciones cliente:

app.get('/api/info', (req, res) => {
  const informacion = {
    version: '1.2.0',
    nombre: 'Mi API Express',
    descripcion: 'API para gestión de productos',
    endpoints: [
      '/productos',
      '/usuario',
      '/pedido',
      '/estadisticas'
    ],
    limitesRed: {
      requestsPorMinuto: 100,
      tamañoMaximo: '10MB'
    }
  };
  
  res.json(informacion);
});

El uso de res.json() en Express simplifica significativamente la creación de APIs modernas, proporcionando una forma limpia y eficiente de enviar datos estructurados. Esta funcionalidad establece la base para construir servicios web robustos que pueden comunicarse efectivamente con aplicaciones frontend, móviles y otros servicios.