Concetpo de rutas

Las rutas son determinan cómo se deben manejar las solicitudes HTTP a tu aplicación .

Especifican qué acción se debe tomar cuando se accede a una URI específica, conectando URLs con el código que genera las respuestas a esas URLs.

En ellas, podemos ver cómo las reglas que determinan cómo se responde a cada petición entrante a tu aplicación web.

Directorio Routes

La carpeta routes en un proyecto Laravel es crucial, ya que en los fichero que contiene, se van a definir cómo tu aplicación responde a las solicitudes HTTP

Después de una instalación estándar, tedremos dos ficheros:

• web.php
  En él, se definen las rutas accesibles a través del navegador, gestionando solicitudes GET, POST, PUT, PATCH, DELETE, OPTIONS. Tendremos otros métodos disponibles, según se verán.
  Aquí puedes agrupar rutas, asignarles middleware para control de acceso, y vincularlas a controladores que manejan la lógica de la aplicación.
• console.php
  Este archivo es donde defines todas las rutas CLI (Command Line Interface) o comandos de Artisan (comando que ejecutaremos desde el terminal para interactuar con nuestra aplicación

Contenido

En el fichero de rutas usaremos simpre la facade Route Es una Interfaz estática que va a permitir invocar a los diferentes métodos para que nuestra aplicación ofrezca recursos web. La idea es establecer ante una solicitud establecer una acción :

En la imagen siguiente especificamos con más detelle el contenido

Routing

• En las aplicaciones que venimos desarrollando en el curso, el proceso de ejecución de la solicitud de un recurso web, de forma básica, es:
  1. El cliente escribe una URL solicitando una página web o PHP. Por ejemplo:

1

http://localhost/paginaPrincipal.php

2. Ahora el servidor web procesa la petición ejecutando el fichero PHP y retornando una página web al cliente.

• Es esta la primera diferencia que podemos encontrar con una aplicación web tradicional de PHP, como hemos trabajado en el curso.
• Ahora no vamos a funcionar exactamente así en la parte del servidor.

Con el routing, vamos a especificar los diferentes recursos que nuestra aplicación va a atender como solicitudes HTTP. Esto se hará en un único fichero donde se especifican estas rutas: web.php, de modo que todo lo relacionado con las rutas esté ahí especificado:

/routes/web.php

URL

• En la versión 12 de Laravel, el archivo principal de rutas es routes/web.php. Las rutas de API o canales se gestionan de forma diferente y están en los ficheros separados como api.php o channels.php.

Contenido de web.php

• El proceso quedará definido por la siguiente secuencia:
  1. El cliente escribirá una ruta a la que quiere acceder en forma de URL.
  2. La aplicación buscará dicha ruta en el fichero web.php.

• Hay diferentes maneras de especificar estas rutas en el fichero web.php, como veremos a continuación.

Levantando el servidor

• Antes de probar las rutas, debemos poner nuestro servidor en funcionamiento. Para ello, cada proyecto tiene un pequeño servidor interno que nos permite probar en local sin necesidad de depender de Apache.

1. Primero levantamos el servidor que viene con Laravel en el puerto 8000.
2. Usamos los comandos de Artisan:

1

php artisan serve

Si estamos usando Docker, debemos indicar que el navegador o la solicitud pueda hacerse desde cualquier host con la opción --host 0.0.0.0:

1

php artisan serve --host 0.0.0.0

Al ejecutar el comando, vemos la siguiente salida, que responde al route con la URL /:

1

Laravel development server started on http://localhost:8000

• Ahora abrimos el navegador y escribimos http://localhost:8000, obteniendo una vista similar a esta:

= Especificando la ruta en Laravel =

Para ello se usa la clase Router. Más información:

Laravel Routing Documentation

Usamos lo que en Laravel se conoce como Facade.

Facade

Facade

inyección de dependencias

De esta forma no tendremos que instanciar un objeto de la clase Router. La clase cuenta con una serie de métodos para especificar las rutas según el tipo de solicitud HTTP que se hace al servidor.

Por ejemplo:

1
2
3
4
5
6
7
8
9

<?php
// app/web.php
Route::get($uri, $callback);
Route::post($uri, $callback);
Route::put($uri, $callback);
Route::patch($uri, $callback);
Route::delete($uri, $callback);
Route::options($uri, $callback);
?>

• También podemos tener métodos más flexibles:

1
2
3
4
5
6
7
8
9

// Cualquiera de los métodos GET o POST
Route::match(['get', 'post'], '/', function () {
//
});

// Cualquier método HTTP
Route::any('foo', function () {
//
});

== Routing básico: funciones anónimas o closures ==

• En este caso, la acción básica será una función anónima o closure.

• Una función de closure es una función sin nombre (anónima) que se ejecutará y puede retornar algún valor.

• Ejemplo: dotamos a nuestra aplicación del recurso o ruta llamada “primera”:

1
2
3

Route::get("primera", function(){
return "<h1>Estás en la página primera con método GET</h1>";
});

• También funciona con echo:

1
2
3

Route::get("primera_echo", function(){
echo "<h1>Estás en la página primera con método GET</h1>";
});

• Podemos devolver una vista o página HTML. Para ello, creamos una vista:

• Ejemplo básico: Creamos la vista prueba.blade.php:

<!doctype html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
<h1>Esto es una prueba</h1>
</body>
</html>

• Agregamos la ruta:

1
2
3

Route::any('about', function(){
return view('prueba');
});

• También podemos usar el método view directamente:

1

Route::view('ruta', 'vista');

Práctica: rutas básicas

Routing parametrizado

• Laravel permite que las rutas incluyan parámetros, los cuales se pasan a las funciones como argumentos.

• Ejemplo básico:

1
2
3

Route::get('/numero/{number}', function($number){
return "<h2>Estás en el número $number</h2>";
});

• Los parámetros en las rutas se indican entre llaves {}. Laravel inyecta automáticamente el valor del parámetro en la función.

• Ejemplo con varios parámetros:

1
2
3

Route::get('noticias/{categoria}/{id}', function($categoria, $id){
return "<h1>Categoria: $categoria, Noticia: $id</h1>";
});

Parámetros con valores por defecto

• Si un parámetro no es obligatorio, podemos asignarle un valor por defecto:

1
2
3

Route::get('/usuario/{nombre?}', function($nombre = 'Invitado'){
return "<h2>Hola, $nombre</h2>";
});

###Práctica: rutas parametrizadas

Restricciones y validación de parámetros

• Podemos usar expresiones regulares para restringir los valores permitidos en los parámetros.

• Ejemplo restringiendo a números:

1
2
3

Route::get('noticias/{id}', function($id){
return "<h2>Noticia número $id</h2>";
})->where('id', '[0-9]+');

• También se pueden aplicar múltiples restricciones:

1
2
3

Route::get('categoria/{name}/{id}', function($name, $id){
return "<h2>Categoria: $name, ID: $id</h2>";
})->where(['name' => '[A-Za-z]+', 'id' => '[0-9]+']);

• Laravel incluye helpers para simplificar estas restricciones:

1
2
3
4
5
6
7

Route::get('user/{name}', function($name){
return "<h2>Usuario: $name</h2>";
})->whereAlpha('name');

Route::get('product/{id}', function($id){
return "<h2>Producto ID: $id</h2>";
})->whereNumber('id');

Parámetros opcionales con validación

• Es posible combinar parámetros opcionales con restricciones:

1
2
3

Route::get('profile/{name?}', function($name = 'Invitado'){
return "<h2>Perfil de: $name</h2>";
})->whereAlpha('name');

Práctica: restricciones y validación

Nomenclatura de rutas

• Podemos asignar nombres a las rutas para facilitar su referencia en la aplicación.

• Ejemplo de nombrado de rutas:

1
2
3
4
5
6
7

Route::get('/home', function(){
return view('home');
})->name('home');

Route::get('/profile', function(){
return view('profile');
})->name('profile');

• Con el nombre asignado, podemos generar URLs dinámicamente:

1
2

$url = route('home'); // Genera la URL de la ruta 'home'
$url = route('profile'); // Genera la URL de la ruta 'profile'

• También es posible redirigir a una ruta nombrada:

1

return redirect()->route('home');

Práctica: nomenclatura de rutas

Route::fallback() en Laravel

¿Qué es?

Route::fallback() define una ruta de respaldo que se ejecuta cuando ninguna otra ruta coincide con la petición actual.

En otras palabras:

Se ejecuta cuando el usuario accede a una URL que no existe en el sistema de rutas.

Es una forma controlada de gestionar el error 404 desde el propio archivo web.php.

Debe colocarse siempre al final del fichero de rutas. , Laravel busca las coincidencias de rutas en orden; si se coloca al principio o en medio, fallback() actuaría como comprobación para cualquier ruta y no llegaría a analizar las que estén definidas después.

Route::fallback(function () {

    $url = request()->url();     // URL completa
    $path = request()->path();   // Solo el path

    return "<h1>La ruta {$path} no existe</h1>";
});

Obtener información de la petición

Dentro del fallback() puedes usar el helper request().

$url = request()->url();

Ejemplo resultado:

http://misitio.test/ruta-inexistente

Solo el path

$path = request()->path();

Ejemplo resultado:

ruta-inexistente

Obtener el nombre de la ruta

Si quieres obtener el nombre de la ruta actual:

$routeName = request()->route()?->getName();

Sin embargo, en un fallback() normalmente no existirá nombre de ruta, porque precisamente no ha coincidido ninguna.

Por eso es recomendable usar:

$routeName = optional(request()->route())->getName();

Si no existe ruta, devolverá null.

Route::fallback(function () {

    $url = request()->url();
    $path = request()->path();
    $routeName = optional(request()->route())->getName();

    return response()->view('errors.custom404', [
        'url' => $url,
        'path' => $path,
        'routeName' => $routeName
    ], 404);
});

• Route::fallback() → Captura cualquier URL no definida.
• request()->url() → Devuelve la URL completa.
• request()->path() → Devuelve solo la ruta.
• request()->route()?->getName() → Devuelve el nombre de la ruta si existe.
• Es recomendable devolver código HTTP 404 y usar una vista personalizada.

Es una herramienta muy útil para controlar errores de navegación de forma elegante dentro del sistema de rutas de Laravel.