Routing

Introducción a rutas básicas

Las rutas en Laravel constituyen el punto de entrada de tu aplicación web, actuando como el mecanismo que conecta las URLs solicitadas por los usuarios con la lógica específica que debe ejecutarse para cada petición. En esencia, una ruta define qué código debe ejecutarse cuando alguien visita una URL particular de tu aplicación.

¿Qué son las rutas?

Una ruta es una definición que asocia una URL específica con una acción determinada. Cuando un usuario visita tu aplicación Laravel, el sistema de enrutamiento examina la URL solicitada y determina qué código ejecutar basándose en las rutas que hayas definido.

Route::get('/bienvenida', function () {
    return '¡Hola mundo desde Laravel!';
});

En este ejemplo básico, cuando alguien visite tudominio.com/bienvenida, Laravel ejecutará la función anónima y mostrará el mensaje "¡Hola mundo desde Laravel!".

Archivos de rutas en Laravel

Laravel organiza las rutas en archivos específicos dentro del directorio routes/. Los archivos principales son:

• routes/web.php: Para rutas web tradicionales que necesitan sesiones, cookies y protección CSRF
• routes/api.php: Para rutas de API que generalmente devuelven JSON y no requieren estado de sesión

// routes/web.php
Route::get('/', function () {
    return 'Página principal de mi aplicación';
});

Route::get('/contacto', function () {
    return 'Página de contacto';
});

Métodos HTTP básicos

Las rutas en Laravel pueden responder a diferentes métodos HTTP. Los más comunes incluyen:

// Método GET - para obtener información
Route::get('/productos', function () {
    return 'Lista de productos';
});

// Método POST - para enviar datos al servidor
Route::post('/productos', function () {
    return 'Crear un nuevo producto';
});

// Método PUT - para actualizar recursos completos
Route::put('/productos/1', function () {
    return 'Actualizar producto con ID 1';
});

// Método DELETE - para eliminar recursos
Route::delete('/productos/1', function () {
    return 'Eliminar producto con ID 1';
});

También puedes crear rutas que respondan a múltiples métodos HTTP usando el método match:

Route::match(['GET', 'POST'], '/formulario', function () {
    return 'Esta ruta acepta GET y POST';
});

// O para todos los métodos HTTP
Route::any('/cualquier-metodo', function () {
    return 'Esta ruta acepta cualquier método HTTP';
});

Rutas con respuestas directas

Las rutas más simples devuelven respuestas directas sin necesidad de lógica compleja:

// Devolver texto plano
Route::get('/texto', function () {
    return 'Esto es texto plano';
});

// Devolver un array (se convierte automáticamente a JSON)
Route::get('/datos', function () {
    return [
        'nombre' => 'Juan',
        'edad' => 25,
        'ciudad' => 'Madrid'
    ];
});

// Devolver HTML básico
Route::get('/html', function () {
    return '<h1>Título principal</h1><p>Contenido HTML</p>';
});

Nombres de rutas

Puedes asignar nombres únicos a tus rutas para referenciarlas fácilmente en otras partes de tu aplicación:

Route::get('/perfil-usuario', function () {
    return 'Perfil del usuario';
})->name('perfil');

Route::get('/configuracion', function () {
    return 'Página de configuración';
})->name('config.principal');

Los nombres de rutas son especialmente útiles porque permiten cambiar la URL sin afectar el resto de tu código. Si decides cambiar /perfil-usuario por /mi-perfil, solo necesitas modificar la definición de la ruta, manteniendo el mismo nombre.

Rutas con patrones básicos

Puedes definir rutas con patrones más específicos para mayor flexibilidad:

// Ruta exacta
Route::get('/sobre-nosotros', function () {
    return 'Información sobre la empresa';
});

// Ruta para la raíz del sitio
Route::get('/', function () {
    return 'Página de inicio';
});

// Rutas anidadas
Route::get('/empresa/historia', function () {
    return 'Historia de la empresa';
});

Route::get('/empresa/equipo', function () {
    return 'Nuestro equipo';
});

Agrupación básica de rutas

Laravel permite agrupar rutas que comparten características comunes, como un prefijo en la URL:

Route::prefix('admin')->group(function () {
    Route::get('/dashboard', function () {
        return 'Panel de administración';
    });
    
    Route::get('/usuarios', function () {
        return 'Gestión de usuarios';
    });
});

Este código crea las rutas /admin/dashboard y /admin/usuarios de manera más organizada.

Orden de las rutas

El orden en que defines las rutas es importante, ya que Laravel evalúa las rutas de arriba hacia abajo y ejecuta la primera que coincida:

// ✅ Orden correcto
Route::get('/productos/nuevo', function () {
    return 'Formulario para nuevo producto';
});

Route::get('/productos/{id}', function ($id) {
    return "Producto con ID: $id";
});

// ❌ Orden incorrecto causaría problemas
// Route::get('/productos/{id}', function ($id) {
//     return "Producto con ID: $id";
// });
// 
// Route::get('/productos/nuevo', function () {
//     return 'Nunca se ejecutaría';
// });

En el ejemplo correcto, Laravel primero verifica si la URL es exactamente /productos/nuevo antes de comprobar el patrón más general /productos/{id}.

Parámetros de ruta

Los parámetros de ruta permiten capturar valores dinámicos desde la URL y pasarlos directamente a tu lógica de aplicación. Esta funcionalidad es fundamental para crear aplicaciones web interactivas que puedan manejar contenido específico basado en los datos de la URL.

Parámetros básicos

Un parámetro de ruta se define utilizando llaves {} en la definición de la ruta. Cuando Laravel encuentra una coincidencia, extrae automáticamente el valor y lo pasa como argumento a la función de callback:

Route::get('/usuario/{id}', function ($id) {
    return "Mostrando información del usuario: " . $id;
});

Cuando alguien visite /usuario/123, Laravel ejecutará la función pasando 123 como valor del parámetro $id.

Múltiples parámetros

Puedes definir múltiples parámetros en una sola ruta, y Laravel los pasará en el mismo orden en que aparecen en la URL:

Route::get('/categoria/{categoria}/producto/{producto}', function ($categoria, $producto) {
    return "Categoría: $categoria, Producto: $producto";
});

Al visitar /categoria/electronica/producto/smartphone, la función recibirá electronica y smartphone como argumentos respectivos.

Parámetros opcionales

Los parámetros opcionales se definen añadiendo un signo de interrogación ? después del nombre del parámetro. Debes proporcionar un valor por defecto en la función:

Route::get('/saludo/{nombre?}', function ($nombre = 'Visitante') {
    return "¡Hola, $nombre!";
});

Esta ruta funcionará tanto para /saludo/Juan (mostrará "¡Hola, Juan!") como para /saludo (mostrará "¡Hola, Visitante!").

Route::get('/buscar/{termino}/{pagina?}', function ($termino, $pagina = 1) {
    return "Buscando '$termino' en la página $pagina";
});

Restricciones con expresiones regulares

Puedes aplicar restricciones a los parámetros usando el método where() con expresiones regulares para validar el formato esperado:

// Solo acepta números
Route::get('/usuario/{id}', function ($id) {
    return "Usuario ID: $id";
})->where('id', '[0-9]+');

// Solo acepta letras
Route::get('/perfil/{usuario}', function ($usuario) {
    return "Perfil de: $usuario";
})->where('usuario', '[A-Za-z]+');

// Múltiples restricciones
Route::get('/articulo/{id}/{slug}', function ($id, $slug) {
    return "Artículo $id: $slug";
})->where(['id' => '[0-9]+', 'slug' => '[a-z-]+']);

Restricciones globales de parámetros

Para aplicar las mismas restricciones a múltiples rutas, puedes definir patrones globales en el método boot() de un service provider:

// En App\Providers\RouteServiceProvider
public function boot()
{
    Route::pattern('id', '[0-9]+');
    Route::pattern('usuario', '[a-zA-Z0-9_-]+');
    
    parent::boot();
}

Una vez definidos estos patrones, todas las rutas que utilicen parámetros con esos nombres aplicarán automáticamente las restricciones:

Route::get('/usuario/{id}', function ($id) {
    return "Usuario: $id";
}); // Automáticamente solo acepta números

Route::get('/perfil/{usuario}', function ($usuario) {
    return "Perfil: $usuario";
}); // Automáticamente aplica el patrón definido

Parámetros con valores complejos

Los parámetros pueden capturar valores más complejos que incluyan guiones, puntos o caracteres especiales:

// Capturar fechas
Route::get('/eventos/{fecha}', function ($fecha) {
    return "Eventos del día: $fecha";
})->where('fecha', '[0-9]{4}-[0-9]{2}-[0-9]{2}');

// Capturar URLs o rutas anidadas
Route::get('/archivo/{ruta}', function ($ruta) {
    return "Accediendo a: $ruta";
})->where('ruta', '.*');

Parámetros numéricos y de cadena

Laravel puede inferir automáticamente el tipo de algunos parámetros, pero es recomendable ser explícito con las restricciones:

// Para IDs numéricos
Route::get('/producto/{id}', function (int $id) {
    return "Producto número: $id";
})->where('id', '[0-9]+');

// Para códigos alfanuméricos
Route::get('/pedido/{codigo}', function (string $codigo) {
    return "Pedido: $codigo";
})->where('codigo', '[A-Z0-9]{8}');

Parámetros con formato de URL

Cuando necesites capturar segmentos de URL que pueden contener barras diagonales, utiliza la restricción .*:

Route::get('/documentos/{ruta_archivo}', function ($ruta_archivo) {
    return "Documento en: $ruta_archivo";
})->where('ruta_archivo', '.*');

Esta ruta puede manejar URLs como /documentos/carpeta/subcarpeta/archivo.pdf.

Combinando parámetros obligatorios y opcionales

Puedes combinar diferentes tipos de parámetros en una sola ruta, recordando que los parámetros opcionales siempre deben ir al final:

Route::get('/tienda/{categoria}/{subcategoria?}/{pagina?}', 
    function ($categoria, $subcategoria = 'todas', $pagina = 1) {
        return "Categoría: $categoria, Subcategoría: $subcategoria, Página: $pagina";
    }
)->where(['categoria' => '[a-z-]+', 'pagina' => '[0-9]+']);

Validación de parámetros en la ruta

Para una validación más robusta, puedes combinar restricciones con validación adicional dentro de la función:

Route::get('/usuario/{id}', function ($id) {
    if ($id < 1 || $id > 9999) {
        abort(404, 'Usuario no encontrado');
    }
    
    return "Mostrando usuario: $id";
})->where('id', '[0-9]+');

Parámetros con nombres descriptivos

Es una buena práctica usar nombres descriptivos para tus parámetros que reflejen claramente qué representan:

// ✅ Nombres claros y descriptivos
Route::get('/blog/{ano}/{mes}/{titulo_articulo}', 
    function ($ano, $mes, $titulo_articulo) {
        return "Artículo: $titulo_articulo del $mes/$ano";
    }
)->where([
    'ano' => '[0-9]{4}',
    'mes' => '[0-9]{2}',
    'titulo_articulo' => '[a-z0-9-]+'
]);

// ❌ Nombres poco descriptivos
Route::get('/blog/{a}/{b}/{c}', function ($a, $b, $c) {
    // Es difícil entender qué representa cada parámetro
});

Los parámetros de ruta proporcionan una forma elegante y eficiente de crear URLs dinámicas que pueden adaptarse a diferentes necesidades de tu aplicación, desde simples identificadores numéricos hasta estructuras más complejas de navegación.