Ultima Laravel
Share
Explore
Ultima Laravel
Enrutamiento

icon picker
Routes

Las rutas se definen en el directorio routes:
web.php define todas las rutas de la aplicación web
api.php define las rutas asociadas a un servicio web
console.php define rutas usadas desde la consola con php artisan
channels.php se usa en aplicaciones en tiempo real y websockets. No toca...
Para definir una ruta usamos una clase llamada Route.
Usamos una función que define el tipo de petición (get, post, ...)
Definimos una ruta
Definimos una función de callback o como veremos un controlador y un método.
Route::get('user', function () {
return 'hola mundo. Estamos en user';
});
Veamos algunos ejemplos ilustrativos:
Route::get('user', function () {
return 'hola mundo. Estamos en user';
});

//prueba esta ruta creando un formulario.
Route::post('user', function () {
return 'hola mundo. Estamos en user, por el método POST';
});

//podemos usar parámetros
Route::get('user/{id}', function ($id) {
return 'Preguntando por user' . $id;
});

//podemos usar parámetros opcionales
Route::get('book/{id?}', function ($id = "desconocido") {
return 'Preguntando por el libro ' . $id;
});

Route::get('user/delete/{id}', function ($id) {
return 'Baja de usuario, argumento id:' . $id;
});

//Podemos filtrar los argumentos con expresiones regulares
Route::get('user/{name}', function ($name) {
// name debe ser texto
}) ->where('name', '[A-Za-z]+');

Route::get('user/{id}', function ($id) {
// id debe ser un nº. natural
}) ->where('id', '[0-9]+')

Rutas básicas

Las rutas, además de definir la URL de la petición, también indican el método con el cual se ha de hacer dicha petición. Los dos métodos más utilizados y que empezaremos viendo son las peticiones tipo GET y tipo POST. Por ejemplo, para definir una petición tipo GET tendríamos que añadir el siguiente código a nuestro fichero routes.php:
Route::get('/', function()
{
return '¡Hola mundo!';
});
Este código se lanzaría cuando se realice una petición tipo GET a la ruta raíz de nuestra aplicación. Si estamos trabajando en local esta ruta sería http://localhost pero cuando la web esté en producción se referiría al dominio principal, por ejemplo: http://www.dirección-de-tu-web.com. Es importante indicar que si se realiza una petición tipo POST o de otro tipo que no sea GET a dicha dirección se devolvería un error ya que esa ruta no está definida.
Para definir una ruta tipo POST se realizaría de la misma forma pero cambiando el verbo GET por POST:
Route::post('foo/bar', function()
{
return '¡Hola mundo!';
});
En este caso la ruta apuntaría a la dirección URL foo/bar (http://localhost/foo/bar o http://www.dirección-de-tu-web.com/foo/bar).
De la misma forma podemos definir rutas para peticiones tipo PUT o DELETE:
Route::put('foo/bar', function () {
//
});
​
Route::delete('foo/bar', function () {
//
});
Si queremos que una ruta se defina a la vez para varios verbos lo podemos hacer añadiendo un array con los tipos, de la siguiente forma:
Route::match(array('GET', 'POST'), '/', function()
{
return '¡Hola mundo!';
});
O para cualquier tipo de petición HTTP utilizando el método any:
Route::any('foo', function()
{
return '¡Hola mundo!';
});

Añadir parámetros a las rutas

Si queremos añadir parámetros a una ruta simplemente los tenemos que indicar entre llaves {} a continuación de la ruta, de la forma:
Route::get('user/{id}', function($id)
{
return 'User '.$id;
});
En este caso estamos definiendo la ruta /user/{id}, donde id es requerido y puede ser cualquier valor. En caso de no especificar ningún id se produciría un error. El parámetro se le pasará a la función, el cual se podrá utilizar (como veremos más adelante) para por ejemplo obtener datos de la base de datos, almacenar valores, etc.
También podemos indicar que un parámetro es opcional simplemente añadiendo el símbolo ? al final (y en este caso no daría error si no se realiza la petición con dicho parámetro):
Route::get('user/{name?}', function($name = null)
{
return $name;
});
​
// También podemos poner algún valor por defecto...
​
Route::get('user/{name?}', function($name = 'Javi')
{
return $name;
});
Laravel también permite el uso de expresiones regulares para validar los parámetros que se le pasan a una ruta. Por ejemplo, para validar que un parámetro esté formado solo por letras o solo por números:
Route::get('user/{name}', function($name)
{
//
})
->where('name', '[A-Za-z]+');
​
Route::get('user/{id}', function($id)
{
//
})
->where('id', '[0-9]+');
​
// Si hay varios parámetros podemos validarlos usando un array:
​
Route::get('user/{id}/{name}', function($id, $name)
{
//
})
->where(array('id' => '[0-9]+', 'name' => '[A-Za-z]+'))

Generar una ruta

Cuando queramos generar la URL hasta una ruta podemos utilizar el siguiente método:
$url = url('foo');
Con este método nos aseguraremos que la URL sea válida y además se le añadirá el dominio que tengamos definido en los ficheros de configuración. En general no será necesaria su utilización y simplemente podremos escribir la ruta a mano hasta una dirección de la forma: /fo o (anteponiendo la barra / para asegurarnos que la ruta sea a partir de la raíz del dominio de nuestro sitio). Sin embargo se recomienda la utilización de este método en general para evitar problemas de generación de rutas no existentes o relativas (si se nos olvidase anteponer la /).

Métodos de enrutamiento disponibles

El router permite registrar rutas que respondan a cualquier verbo HTTP:
Route::get($uri, $callback);
Route::post($uri, $callback);
Route::put($uri, $callback);
Route::patch($uri, $callback);
Route::delete($uri, $callback);
Route::options($uri, $callback);
En ocasiones puede ser necesario una ruta que responda a varios verbos HTTP. Puede hacerse utilizando el método match. O incluso se puede registrar una ruta que responda a todos los verbos HTTP utilizando el método any:
Route::match(['get', 'post'], '/', function () {
//
});
Route::any('/', function () {
//
});

# Protección CSRF

Cualquier formulario HTML que apunte a una ruta POST, PUT o DELETE definida en el archivo de rutas web debe incluir un campo con un token CSRF. De lo contrario, la petición se rechazará. Se puede averiguar más sobre protección CSRF en la documentación CSRF:
<form method="POST" action="/profile">
@csrf
...
</form>

Redireccionar las rutas

Si está definiendo una ruta que redirige a otra URI, puede usar el método Route::redirect. Este método proporciona un atajo conveniente para que no tengas que definir una ruta completa o un controlador para realizar una redirección simple:
Route::redirect('/here', '/there');
Por defecto, Route::redirect devuelve un código de estado 302. Puede personalizar el código de estado utilizando el tercer parámetro opcional:
Route::redirect('/here', '/there', 301);
Puede usar el método Route::permanentRedirect para devolver un código de estado 301:
Route::permanentRedirect('/here', '/there');

Rutas con vistas

Si únicamente se necesita devolver una vista desde una ruta, se puede utilizar el método Route::view. Al igual que el método redirect, este método es como un acceso directo para no tener que definir la ruta completa o un controlador. El método view acepta una URI como primer parámetro y un nombre de vista como segundo. Además, se le puede pasar un array de datos a la vista como tercer parámetro opcional:
Route::view('/welcome', 'welcome');
Route::view('/welcome', 'welcome', ['name' => 'Taylor']);

# Rutas con parámetros

Parámetros requeridos

A veces necesitarás capturar segmentos de la URI dentro de tu ruta. Por ejemplo, puede que necesites capturar el ID de un usuario de la URL. Puede hacerlo definiendo los parámetros de la ruta:
Route::get('user/{id}', function ($id) {
return 'User '.$id;
});
Puede definir tantos parámetros de ruta como sean requeridos por su ruta:
Route::get('posts/{post}/comments/{comment}', function ($postId, $commentId) {
//
});
Los parámetros de ruta se definen siempre dentro de llaves {} y deben contener únicamente caracteres alfabéticos y nunca contener - (guiones). Instead of using the - character, use an underscore (_). Los parámetros de rutas se inyectan directamente en los callback/controladores en orden – los nombres de los argumentos no afectan.

Parámetros opcionales

A veces es necesario especificar un parámetro, pero la presencia de este parámetro es opcional. Se puede definir simplemente añadiendo el símbolo ? detrás del nombre del parámetro. Asegúrese de dar a esa variable un valor por defecto en su callback/controlador:
Route::get('user/{name?}', function ($name = null) {
return $name;
});
Route::get('user/{name?}', function ($name = 'John') {
return $name;
});

Expresiones regulares

Es posible limitar el formato de los elementos dentro de los parámetros de una ruta usando el método where en una instancia de Route. El método where acepta el nombre del parámetro y la expresión regular que define como se debe limitar el parámetro:
Route::get('user/{name}', function ($name) {
//
})->where('name', '[A-Za-z]+');
Route::get('user/{id}', function ($id) {
//
})->where('id', '[0-9]+');
Route::get('user/{id}/{name}', function ($id, $name) {
//
})->where(['id' => '[0-9]+', 'name' => '[a-z]+']);

Restricciones globales

Si se desea que un parámetro de ruta siempre este limitado por una expresión regular definida, se puede hace utilizando el método pattern. Estos patrones se deben definir en el método boot dentro del RouteServiceProvider:
/**
* Define your route model bindings, pattern filters, etc.
*
* @return void
*/
public function boot()
{
Route::pattern('id', '[0-9]+');
}
Una vez que el patrón se haya sido definido, se aplicará automáticamente a todas las rutas que utilicen ese nombre como parámetro:
Route::get('user/{id}', function ($id) {
// Only executed if {id} is numeric...
});

Cifrado de los cortes hacia adelante

El componente de enrutamiento de Laravel permite todos los caracteres excepto /. Debe permitir explícitamente que / sea parte de su marcador de posición usando una expresión regular de la condición where:
Route::get('search/{search}', function ($search) {
return $search;
})->where('search', '.*');
Las barras codificadas de avance sólo se admiten en el último segmento de ruta.

# Nombre de rutas

Las rutas con nombre permiten la generación de URL o redirecciones para rutas específicas. Se puede especificar el nombre de una ruta encadenando el método name a la definición de la ruta:
Route::get('user/profile', function () {
//
})->name('profile');
También se pueden especificar nombres de rutas para acciones de controladores:
Route::get('user/profile', [UserProfileController::class, 'show'])->name('profile');
Los nombres de las rutas siempre deben ser únicos.

Generando URLs para las rutas nombradas

Una vez que haya asignado un nombre a una ruta determinada, puede usar el nombre de la ruta al generar URL o redirecciones a través de la route función global:
// Generating URLs...
$url = route('profile');
// Generating Redirects...
return redirect()->route('profile');
Si la ruta nombrada define parámetros, puede pasar los parámetros como segundo argumento a la función "route". Los parámetros dados se insertarán automáticamente en la URL en sus posiciones correctas:
Route::get('user/{id}/profile', function ($id) {
//
})->name('profile');
$url = route('profile', ['id' => 1]);
Si pasas parámetros adicionales en el array, esos pares clave/valor se añadirán automáticamente a la cadena de consulta de la URL generada
Route::get('user/{id}/profile', function ($id) {
//
})->name('profile');
$url = route('profile', ['id' => 1, 'photos' => 'yes']);
// /user/1/profile?photos=yes
A veces, puede que desee especificar valores predeterminados de solicitud para los parámetros de la URL, como la localidad actual. Para ello, puede utilizar la función URL::defaults method.

Inspeccionando la ruta actual

Para determinar si la petición actual coincide con el nombre de alguna ruta, se puede utilizar el método named de una instancia de Route. Por ejemplo, se puede comprobar el nombre de la ruta actual desde un middleware de ruta:
/**
* Handle an incoming request.
*
* @param \Illuminate\Http\Request $request
* @param \Closure $next
* @return mixed
*/
public function handle($request, Closure $next)
{
if ($request->route()->name('profile')) {
//
}
return $next($request);
}

# Grupo de rutas

Los Grupos de Rutas permiten compartir atributos de ruta, por ejemplo middleware o namespaces, a un grupo de rutas sin necesidad de definir los atributos a cada una de manera individual. Los atributos compartidos se pasan en un como array al primer parámetro del método Route::group.
Los grupos anidados intentan "merge" inteligentemente los atributos con su grupo matriz. Las condiciones Middleware y where se fusionan mientras que los nombres y prefijos se añaden. Los delimitadores del espacio de nombres y las barras en los prefijos URI se añaden automáticamente cuando es apropiado.

Middleware

Para asignar un middleware a todas las rutas de un grupo, se puede utilizar el método middleware antes de definir el grupo. Los middleware se ejecutarán en en el mismo orden que se pasen en el array:
Route::middleware(['first', 'second'])->group(function () {
Route::get('/', function () {
Gallery
Share
 
Want to print your doc?
This is not the way.
Try clicking the ⋯ next to your doc name or using a keyboard shortcut (
CtrlP
) instead.