Enrutamiento

• Enrutamiento básico
  • Rutas de redirección
  • Rutas de vista
  • La lista de rutas
• Parámetros de ruta
  • Parámetros obligatorios
  • Parámetros opcionales
  • Restricciones con expresiones regulares
• Rutas nombradas
• Grupos de rutas
  • Middleware
  • Controladores
  • Enrutamiento por subdominio
  • Prefijos de ruta
  • Prefijos de nombre de ruta
• Vinculación de modelos en rutas
  • Vinculación implícita
  • Vinculación implícita de Enum
  • Vinculación explícita
• Rutas de reserva
• Limitación de tasa
  • Definición de limitadores de tasa
  • Asignación de limitadores de tasa a rutas
• Simulación de método en formularios
• Acceso a la ruta actual
• Compartición de recursos entre orígenes (CORS)
• Caché de rutas

#Enrutamiento básico

Las rutas más básicas de Laravel aceptan un URI y una closure, proporcionando un método muy simple y expresivo para definir rutas y comportamientos sin archivos de configuración de rutas complicados:

use Illuminate\Support\Facades\Route;

Route::get('/greeting', function () {
    return 'Hello World';
});

#Los archivos de rutas por defecto

Todas las rutas de Laravel se definen en sus archivos de rutas, que se encuentran en el directorio routes. Estos archivos son cargados automáticamente por el App\Providers\RouteServiceProvider de su aplicación. El archivo routes/web.php define rutas para su interfaz web. Estas rutas se asignan al grupo de middleware web, que proporciona características como estado de sesión y protección CSRF. Las rutas en routes/api.php son sin estado y se asignan al grupo de middleware api.

Para la mayoría de las aplicaciones, comenzará definiendo rutas en su archivo routes/web.php. Las rutas definidas en routes/web.php pueden ser accedidas ingresando la URL de la ruta definida en su navegador. Por ejemplo, puede acceder a la siguiente ruta navegando a http://example.com/user en su navegador:

use App\Http\Controllers\UserController;

Route::get('/user', [UserController::class, 'index']);

Las rutas definidas en el archivo routes/api.php están anidadas dentro de un grupo de rutas por el RouteServiceProvider. Dentro de este grupo, el prefijo URI /api se aplica automáticamente, por lo que no necesita aplicarlo manualmente a cada ruta en el archivo. Puede modificar el prefijo y otras opciones del grupo de rutas modificando su clase RouteServiceProvider.

#Métodos disponibles en el router

El router le permite registrar rutas que responden 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);

A veces puede necesitar registrar una ruta que responda a múltiples verbos HTTP. Puede hacerlo usando el método match. O incluso puede registrar una ruta que responda a todos los verbos HTTP usando el método any:

Route::match(['get', 'post'], '/', function () {
    // ...
});

Route::any('/', function () {
    // ...
});

#Inyección de dependencias

Puede indicar cualquier dependencia requerida por su ruta en la firma de la callback de la ruta. Las dependencias declaradas serán resueltas e inyectadas automáticamente en la callback por el contenedor de servicios de Laravel. Por ejemplo, puede indicar la clase Illuminate\Http\Request para que la solicitud HTTP actual sea inyectada automáticamente en la callback de la ruta:

use Illuminate\Http\Request;

Route::get('/users', function (Request $request) {
    // ...
});

#Protección CSRF

Recuerde, cualquier formulario HTML que apunte a rutas POST, PUT, PATCH o DELETE definidas en el archivo de rutas web debe incluir un campo de token CSRF. De lo contrario, la solicitud será rechazada. Puede leer más sobre la protección CSRF en la documentación de CSRF:

<form method="POST" action="/profile">
    @csrf
    ...
</form>

#Rutas de redirección

Si está definiendo una ruta que redirige a otro URI, puede usar el método Route::redirect. Este método proporciona un atajo conveniente para que no tenga 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 usando el tercer parámetro opcional:

Route::redirect('/here', '/there', 301);

O puede usar el método Route::permanentRedirect para devolver un código de estado 301:

Route::permanentRedirect('/here', '/there');

#Rutas de vista

Si su ruta solo necesita devolver una vista, puede usar el método Route::view. Al igual que el método redirect, este método proporciona un atajo simple para que no tenga que definir una ruta completa o un controlador. El método view acepta un URI como primer argumento y un nombre de vista como segundo argumento. Además, puede proporcionar un array de datos para pasar a la vista como tercer argumento opcional:

Route::view('/welcome', 'welcome');

Route::view('/welcome', 'welcome', ['name' => 'Taylor']);

#La lista de rutas

El comando Artisan route:list puede proporcionar fácilmente una visión general de todas las rutas definidas por su aplicación:

php artisan route:list

Por defecto, los middleware asignados a cada ruta no se mostrarán en la salida de route:list; sin embargo, puede indicar a Laravel que muestre los middleware de ruta y los nombres de los grupos de middleware agregando la opción -v al comando:

php artisan route:list -v

# Expandir grupos de middleware...
php artisan route:list -vv

También puede indicar a Laravel que solo muestre rutas que comiencen con un URI dado:

php artisan route:list --path=api

Además, puede indicar a Laravel que oculte cualquier ruta definida por paquetes de terceros proporcionando la opción --except-vendor al ejecutar el comando route:list:

php artisan route:list --except-vendor

De igual manera, puede indicar a Laravel que solo muestre rutas definidas por paquetes de terceros proporcionando la opción --only-vendor al ejecutar el comando route:list:

php artisan route:list --only-vendor

#Parámetros de ruta

#Parámetros obligatorios

A veces necesitará capturar segmentos del URI dentro de su ruta. Por ejemplo, puede necesitar capturar el ID de un usuario desde la URL. Puede hacerlo definiendo parámetros de ruta:

Route::get('/user/{id}', function (string $id) {
    return 'User '.$id;
});

Puede definir tantos parámetros de ruta como requiera su ruta:

Route::get('/posts/{post}/comments/{comment}', function (string $postId, string $commentId) {
    // ...
});

Los parámetros de ruta siempre están encerrados entre llaves {} y deben consistir en caracteres alfabéticos. Los guiones bajos (_) también son aceptables dentro de los nombres de parámetros de ruta. Los parámetros de ruta se inyectan en las callbacks/controladores de ruta según su orden; los nombres de los argumentos en la callback/controlador no importan.

#Parámetros e inyección de dependencias

Si su ruta tiene dependencias que desea que el contenedor de servicios de Laravel inyecte automáticamente en la callback de su ruta, debe listar sus parámetros de ruta después de sus dependencias:

use Illuminate\Http\Request;

Route::get('/user/{id}', function (Request $request, string $id) {
    return 'User '.$id;
});

#Parámetros opcionales

Ocasionalmente puede necesitar especificar un parámetro de ruta que no siempre esté presente en el URI. Puede hacerlo colocando un signo ? después del nombre del parámetro. Asegúrese de darle un valor por defecto a la variable correspondiente de la ruta:

Route::get('/user/{name?}', function (?string $name = null) {
    return $name;
});

Route::get('/user/{name?}', function (?string $name = 'John') {
    return $name;
});

#Restricciones con expresiones regulares

Puede restringir el formato de sus parámetros de ruta usando el método where en una instancia de ruta. El método where acepta el nombre del parámetro y una expresión regular que define cómo debe restringirse el parámetro:

Route::get('/user/{name}', function (string $name) {
    // ...
})->where('name', '[A-Za-z]+');

Route::get('/user/{id}', function (string $id) {
    // ...
})->where('id', '[0-9]+');

Route::get('/user/{id}/{name}', function (string $id, string $name) {
    // ...
})->where(['id' => '[0-9]+', 'name' => '[a-z]+']);

Para mayor comodidad, algunos patrones de expresiones regulares comúnmente usados tienen métodos auxiliares que le permiten agregar rápidamente restricciones de patrón a sus rutas:

Route::get('/user/{id}/{name}', function (string $id, string $name) {
    // ...
})->whereNumber('id')->whereAlpha('name');

Route::get('/user/{name}', function (string $name) {
    // ...
})->whereAlphaNumeric('name');

Route::get('/user/{id}', function (string $id) {
    // ...
})->whereUuid('id');

Route::get('/user/{id}', function (string $id) {
    //
})->whereUlid('id');

Route::get('/category/{category}', function (string $category) {
    // ...
})->whereIn('category', ['movie', 'song', 'painting']);

Si la solicitud entrante no coincide con las restricciones del patrón de ruta, se devolverá una respuesta HTTP 404.

#Restricciones globales

Si desea que un parámetro de ruta siempre esté restringido por una expresión regular dada, puede usar el método pattern. Debe definir estos patrones en el método boot de su clase App\Providers\RouteServiceProvider:

/**
 * Defina sus vinculaciones de modelos de ruta, filtros de patrón, etc.
 */
public function boot(): void
{
    Route::pattern('id', '[0-9]+');
}

Una vez definido el patrón, se aplica automáticamente a todas las rutas que usan ese nombre de parámetro:

Route::get('/user/{id}', function (string $id) {
    // Solo se ejecuta si {id} es numérico...
});

#Barras diagonales codificadas

El componente de enrutamiento de Laravel permite que todos los caracteres excepto / estén presentes dentro de los valores de los parámetros de ruta. Debe permitir explícitamente que / sea parte de su marcador de posición usando una expresión regular en la condición where:

Route::get('/search/{search}', function (string $search) {
    return $search;
})->where('search', '.*');

#Rutas nombradas

Las rutas nombradas permiten la generación conveniente de URLs o redirecciones para rutas específicas. Puede especificar un nombre para una ruta encadenando el método name a la definición de la ruta:

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

También puede especificar nombres de ruta para acciones de controlador:

Route::get(
    '/user/profile',
    [UserProfileController::class, 'show']
)->name('profile');

#Generación de URLs para rutas nombradas

Una vez que haya asignado un nombre a una ruta dada, puede usar el nombre de la ruta al generar URLs o redirecciones mediante las funciones helper route y redirect de Laravel:

// Generando URLs...
$url = route('profile');

// Generando redirecciones...
return redirect()->route('profile');

return to_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 generada en sus posiciones correctas:

Route::get('/user/{id}/profile', function (string $id) {
    // ...
})->name('profile');

$url = route('profile', ['id' => 1]);

Si pasa parámetros adicionales en el array, esos pares clave/valor se agregarán automáticamente a la cadena de consulta de la URL generada:

Route::get('/user/{id}/profile', function (string $id) {
    // ...
})->name('profile');

$url = route('profile', ['id' => 1, 'photos' => 'yes']);

// /user/1/profile?photos=yes

#Inspeccionando la ruta actual

Si desea determinar si la solicitud actual fue enrutada a una ruta nombrada dada, puede usar el método named en una instancia de Route. Por ejemplo, puede verificar el nombre de la ruta actual desde un middleware de ruta:

use Closure;
use Illuminate\Http\Request;
use Symfony\Component\HttpFoundation\Response;

/**
 * Manejar una solicitud entrante.
 *
 * @param  \Closure(\Illuminate\Http\Request): (\Symfony\Component\HttpFoundation\Response)  $next
 */
public function handle(Request $request, Closure $next): Response
{
    if ($request->route()->named('profile')) {
        // ...
    }

    return $next($request);
}

#Grupos de rutas

Los grupos de rutas le permiten compartir atributos de ruta, como middleware, a través de un gran número de rutas sin necesidad de definir esos atributos en cada ruta individual.

Los grupos anidados intentan "fusionar" inteligentemente los atributos con su grupo padre. Middleware y condiciones where se fusionan mientras que los nombres y prefijos se agregan al final. Los delimitadores de espacio de nombres y las barras en los prefijos URI se agregan automáticamente donde corresponda.

#Middleware

Para asignar middleware a todas las rutas dentro de un grupo, puede usar el método middleware antes de definir el grupo. Los middleware se ejecutan en el orden en que están listados en el array:

Route::middleware(['first', 'second'])->group(function () {
    Route::get('/', function () {
        // Usa middleware first y second...
    });

    Route::get('/user/profile', function () {
        // Usa middleware first y second...
    });
});

#Controladores

Si un grupo de rutas utiliza el mismo controlador, puede usar el método controller para definir el controlador común para todas las rutas dentro del grupo. Luego, al definir las rutas, solo necesita proporcionar el método del controlador que invocan:

use App\Http\Controllers\OrderController;

Route::controller(OrderController::class)->group(function () {
    Route::get('/orders/{id}', 'show');
    Route::post('/orders', 'store');
});

#Enrutamiento por subdominio

Los grupos de rutas también pueden usarse para manejar el enrutamiento por subdominio. Los subdominios pueden asignarse parámetros de ruta igual que los URIs de ruta, permitiéndole capturar una parte del subdominio para usarla en su ruta o controlador. El subdominio puede especificarse llamando al método domain antes de definir el grupo:

Route::domain('{account}.example.com')->group(function () {
    Route::get('user/{id}', function (string $account, string $id) {
        // ...
    });
});

#Prefijos de ruta

El método prefix puede usarse para prefijar cada ruta en el grupo con un URI dado. Por ejemplo, puede querer prefijar todos los URIs de ruta dentro del grupo con admin:

Route::prefix('admin')->group(function () {
    Route::get('/users', function () {
        // Coincide con la URL "/admin/users"
    });
});

#Prefijos de nombre de ruta

El método name puede usarse para prefijar cada nombre de ruta en el grupo con una cadena dada. Por ejemplo, puede querer prefijar los nombres de todas las rutas en el grupo con admin. La cadena dada se prefija al nombre de la ruta exactamente como se especifica, por lo que debemos asegurarnos de proporcionar el carácter . al final del prefijo:

Route::name('admin.')->group(function () {
    Route::get('/users', function () {
        // Ruta asignada con nombre "admin.users"...
    })->name('users');
});

#Vinculación de modelos en rutas

Al inyectar un ID de modelo en una ruta o acción de controlador, a menudo consultará la base de datos para recuperar el modelo que corresponde a ese ID. La vinculación de modelos en rutas de Laravel proporciona una forma conveniente de inyectar automáticamente las instancias de modelo directamente en sus rutas. Por ejemplo, en lugar de inyectar el ID de un usuario, puede inyectar la instancia completa del modelo User que coincide con el ID dado.

#Vinculación implícita

Laravel resuelve automáticamente los modelos Eloquent definidos en rutas o acciones de controlador cuyos nombres de variables con type-hint coinciden con un segmento de ruta. Por ejemplo:

use App\Models\User;

Route::get('/users/{user}', function (User $user) {
    return $user->email;
});

Dado que la variable $user está type-hint como el modelo Eloquent App\Models\User y el nombre de la variable coincide con el segmento URI {user}, Laravel inyectará automáticamente la instancia del modelo que tenga un ID que coincida con el valor correspondiente de la URI de la solicitud. Si no se encuentra una instancia de modelo coincidente en la base de datos, se generará automáticamente una respuesta HTTP 404.

Por supuesto, la vinculación implícita también es posible al usar métodos de controlador. Nuevamente, note que el segmento URI {user} coincide con la variable $user en el controlador que contiene un type-hint App\Models\User:

use App\Http\Controllers\UserController;
use App\Models\User;

// Definición de ruta...
Route::get('/users/{user}', [UserController::class, 'show']);

// Definición del método del controlador...
public function show(User $user)
{
    return view('user.profile', ['user' => $user]);
}

#Modelos eliminados suavemente

Normalmente, la vinculación implícita de modelos no recuperará modelos que hayan sido eliminados suavemente. Sin embargo, puede indicar a la vinculación implícita que recupere estos modelos encadenando el método withTrashed a la definición de su ruta:

use App\Models\User;

Route::get('/users/{user}', function (User $user) {
    return $user->email;
})->withTrashed();

#Personalizando la clave

A veces puede desear resolver modelos Eloquent usando una columna distinta a id. Para hacerlo, puede especificar la columna en la definición del parámetro de ruta:

use App\Models\Post;

Route::get('/posts/{post:slug}', function (Post $post) {
    return $post;
});

Si desea que la vinculación de modelos siempre use una columna de base de datos distinta a id al recuperar una clase de modelo dada, puede sobrescribir el método getRouteKeyName en el modelo Eloquent:

/**
 * Obtener la clave de ruta para el modelo.
 */
public function getRouteKeyName(): string
{
    return 'slug';
}

#Claves personalizadas y ámbito

Al vincular implícitamente múltiples modelos Eloquent en una sola definición de ruta, puede desear limitar el segundo modelo Eloquent para que sea hijo del modelo Eloquent anterior. Por ejemplo, considere esta definición de ruta que recupera una publicación de blog por slug para un usuario específico:

use App\Models\Post;
use App\Models\User;

Route::get('/users/{user}/posts/{post:slug}', function (User $user, Post $post) {
    return $post;
});

Al usar una vinculación implícita con clave personalizada como parámetro de ruta anidado, Laravel limitará automáticamente la consulta para recuperar el modelo anidado por su padre usando convenciones para adivinar el nombre de la relación en el padre. En este caso, se asumirá que el modelo User tiene una relación llamada posts (la forma plural del nombre del parámetro de ruta) que puede usarse para recuperar el modelo Post.

Si lo desea, puede indicar a Laravel que limite las vinculaciones "hijas" incluso cuando no se proporcione una clave personalizada. Para hacerlo, puede invocar el método scopeBindings al definir su ruta:

use App\Models\Post;
use App\Models\User;

Route::get('/users/{user}/posts/{post}', function (User $user, Post $post) {
    return $post;
})->scopeBindings();

O puede indicar a todo un grupo de definiciones de ruta que usen vinculaciones con ámbito:

Route::scopeBindings()->group(function () {
    Route::get('/users/{user}/posts/{post}', function (User $user, Post $post) {
        return $post;
    });
});

De manera similar, puede indicar explícitamente a Laravel que no limite las vinculaciones invocando el método withoutScopedBindings:

Route::get('/users/{user}/posts/{post:slug}', function (User $user, Post $post) {
    return $post;
})->withoutScopedBindings();

#Personalizando el comportamiento cuando falta el modelo

Normalmente, se generará una respuesta HTTP 404 si no se encuentra un modelo vinculado implícitamente. Sin embargo, puede personalizar este comportamiento llamando al método missing al definir su ruta. El método missing acepta una closure que se invocará si no se puede encontrar un modelo vinculado implícitamente:

use App\Http\Controllers\LocationsController;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Redirect;

Route::get('/locations/{location:slug}', [LocationsController::class, 'show'])
        ->name('locations.view')
        ->missing(function (Request $request) {
            return Redirect::route('locations.index');
        });

#Vinculación implícita de Enum

PHP 8.1 introdujo soporte para Enums. Para complementar esta característica, Laravel le permite indicar un Enum respaldado por string en su definición de ruta y Laravel solo invocará la ruta si ese segmento de ruta corresponde a un valor válido del Enum. De lo contrario, se devolverá automáticamente una respuesta HTTP 404. Por ejemplo, dado el siguiente Enum:

<?php

namespace App\Enums;

enum Category: string
{
    case Fruits = 'fruits';
    case People = 'people';
}

Puede definir una ruta que solo se invocará si el segmento de ruta {category} es fruits o people. De lo contrario, Laravel devolverá una respuesta HTTP 404:

use App\Enums\Category;
use Illuminate\Support\Facades\Route;

Route::get('/categories/{category}', function (Category $category) {
    return $category->value;
});

#Vinculación explícita

No está obligado a usar la resolución implícita basada en convenciones de Laravel para usar la vinculación de modelos. También puede definir explícitamente cómo los parámetros de ruta corresponden a modelos. Para registrar una vinculación explícita, use el método model del router para especificar la clase para un parámetro dado. Debe definir sus vinculaciones explícitas de modelo al inicio del método boot de su clase RouteServiceProvider:

use App\Models\User;
use Illuminate\Support\Facades\Route;

/**
 * Defina sus vinculaciones de modelos de ruta, filtros de patrón, etc.
 */
public function boot(): void
{
    Route::model('user', User::class);

    // ...
}

Luego, defina una ruta que contenga un parámetro {user}:

use App\Models\User;

Route::get('/users/{user}', function (User $user) {
    // ...
});

Dado que hemos vinculado todos los parámetros {user} al modelo App\Models\User, se inyectará una instancia de esa clase en la ruta. Por ejemplo, una solicitud a users/1 inyectará la instancia User de la base de datos que tiene un ID de 1.

Si no se encuentra una instancia de modelo coincidente en la base de datos, se generará automáticamente una respuesta HTTP 404.

#Personalizando la lógica de resolución

Si desea definir su propia lógica de resolución de vinculación de modelo, puede usar el método Route::bind. La closure que pase al método bind recibirá el valor del segmento URI y debe devolver la instancia de la clase que debe inyectarse en la ruta. Nuevamente, esta personalización debe realizarse en el método boot del RouteServiceProvider de su aplicación:

use App\Models\User;
use Illuminate\Support\Facades\Route;

/**
 * Defina sus vinculaciones de modelos de ruta, filtros de patrón, etc.
 */
public function boot(): void
{
    Route::bind('user', function (string $value) {
        return User::where('name', $value)->firstOrFail();
    });

    // ...
}

Alternativamente, puede sobrescribir el método resolveRouteBinding en su modelo Eloquent. Este método recibirá el valor del segmento URI y debe devolver la instancia de la clase que debe inyectarse en la ruta:

/**
 * Recuperar el modelo para un valor vinculado.
 *
 * @param  mixed  $value
 * @param  string|null  $field
 * @return \Illuminate\Database\Eloquent\Model|null
 */
public function resolveRouteBinding($value, $field = null)
{
    return $this->where('name', $value)->firstOrFail();
}

Si una ruta está utilizando vinculación implícita con ámbito, el método resolveChildRouteBinding se usará para resolver la vinculación hija del modelo padre:

/**
 * Recuperar el modelo hijo para un valor vinculado.
 *
 * @param  string  $childType
 * @param  mixed  $value
 * @param  string|null  $field
 * @return \Illuminate\Database\Eloquent\Model|null
 */
public function resolveChildRouteBinding($childType, $value, $field)
{
    return parent::resolveChildRouteBinding($childType, $value, $field);
}

#Rutas de reserva

Usando el método Route::fallback, puede definir una ruta que se ejecutará cuando ninguna otra ruta coincida con la solicitud entrante. Normalmente, las solicitudes no manejadas renderizarán automáticamente una página "404" a través del manejador de excepciones de su aplicación. Sin embargo, dado que normalmente definiría la ruta fallback dentro de su archivo routes/web.php, todos los middleware en el grupo de middleware web se aplicarán a la ruta. Puede agregar middleware adicionales a esta ruta según sea necesario:

Route::fallback(function () {
    // ...
});

#Limitación de tasa

#Definición de limitadores de tasa

Laravel incluye servicios de limitación de tasa potentes y personalizables que puede utilizar para restringir la cantidad de tráfico para una ruta o grupo de rutas dado. Para comenzar, debe definir configuraciones de limitadores de tasa que satisfagan las necesidades de su aplicación.

Normalmente, los limitadores de tasa se definen dentro del método boot de la clase App\Providers\RouteServiceProvider de su aplicación. De hecho, esta clase ya incluye una definición de limitador de tasa que se aplica a las rutas en el archivo routes/api.php de su aplicación:

use Illuminate\Cache\RateLimiting\Limit;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\RateLimiter;

/**
 * Defina sus vinculaciones de modelos de ruta, filtros de patrón y otra configuración de ruta.
 */
protected function boot(): void
{
    RateLimiter::for('api', function (Request $request) {
        return Limit::perMinute(60)->by($request->user()?->id ?: $request->ip());
    });

    // ...
}

Los limitadores de tasa se definen usando el método for de la fachada RateLimiter. El método for acepta un nombre de limitador de tasa y una closure que devuelve la configuración de límite que debe aplicarse a las rutas asignadas al limitador de tasa. Las configuraciones de límite son instancias de la clase Illuminate\Cache\RateLimiting\Limit. Esta clase contiene métodos "builder" útiles para que pueda definir rápidamente su límite. El nombre del limitador de tasa puede ser cualquier cadena que desee:

use Illuminate\Cache\RateLimiting\Limit;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\RateLimiter;

/**
 * Defina sus vinculaciones de modelos de ruta, filtros de patrón y otra configuración de ruta.
 */
protected function boot(): void
{
    RateLimiter::for('global', function (Request $request) {
        return Limit::perMinute(1000);
    });

    // ...
}

Si la solicitud entrante excede el límite de tasa especificado, Laravel devolverá automáticamente una respuesta con código de estado HTTP 429. Si desea definir su propia respuesta que debe devolver un límite de tasa, puede usar el método response:

RateLimiter::for('global', function (Request $request) {
    return Limit::perMinute(1000)->response(function (Request $request, array $headers) {
        return response('Respuesta personalizada...', 429, $headers);
    });
});

Dado que las callbacks de limitador de tasa reciben la instancia de la solicitud HTTP entrante, puede construir el límite de tasa apropiado dinámicamente basado en la solicitud entrante o el usuario autenticado:

RateLimiter::for('uploads', function (Request $request) {
    return $request->user()->vipCustomer()
                ? Limit::none()
                : Limit::perMinute(100);
});

#Segmentación de límites de tasa

A veces puede desear segmentar los límites de tasa por algún valor arbitrario. Por ejemplo, puede querer permitir que los usuarios accedan a una ruta dada 100 veces por minuto por dirección IP. Para lograr esto, puede usar el método by al construir su límite de tasa:

RateLimiter::for('uploads', function (Request $request) {
    return $request->user()->vipCustomer()
                ? Limit::none()
                : Limit::perMinute(100)->by($request->ip());
});

Para ilustrar esta característica con otro ejemplo, podemos limitar el acceso a la ruta a 100 veces por minuto por ID de usuario autenticado o 10 veces por minuto por dirección IP para invitados:

RateLimiter::for('uploads', function (Request $request) {
    return $request->user()
                ? Limit::perMinute(100)->by($request->user()->id)
                : Limit::perMinute(10)->by($request->ip());
});

#Múltiples límites de tasa

Si es necesario, puede devolver un array de límites de tasa para una configuración de limitador de tasa dada. Cada límite de tasa será evaluado para la ruta según el orden en que estén colocados en el array:

RateLimiter::for('login', function (Request $request) {
    return [
        Limit::perMinute(500),
        Limit::perMinute(3)->by($request->input('email')),
    ];
});

#Asignación de limitadores de tasa a rutas

Los limitadores de tasa pueden asignarse a rutas o grupos de rutas usando el middleware throttle middleware. El middleware throttle acepta el nombre del limitador de tasa que desea asignar a la ruta:

Route::middleware(['throttle:uploads'])->group(function () {
    Route::post('/audio', function () {
        // ...
    });

    Route::post('/video', function () {
        // ...
    });
});

#Limitación con Redis

Normalmente, el middleware throttle está mapeado a la clase Illuminate\Routing\Middleware\ThrottleRequests. Este mapeo se define en el kernel HTTP de su aplicación (App\Http\Kernel). Sin embargo, si está usando Redis como driver de caché de su aplicación, puede querer cambiar este mapeo para usar la clase Illuminate\Routing\Middleware\ThrottleRequestsWithRedis. Esta clase es más eficiente para manejar la limitación de tasa usando Redis:

'throttle' => \Illuminate\Routing\Middleware\ThrottleRequestsWithRedis::class,

#Simulación de método en formularios

Los formularios HTML no soportan acciones PUT, PATCH o DELETE. Por lo tanto, al definir rutas PUT, PATCH o DELETE que se llaman desde un formulario HTML, deberá agregar un campo oculto _method al formulario. El valor enviado con el campo _method se usará como el método de la solicitud HTTP:

<form action="/example" method="POST">
    <input type="hidden" name="_method" value="PUT">
    <input type="hidden" name="_token" value="{{ csrf_token() }}">
</form>

Para mayor comodidad, puede usar la directiva Blade @method para generar el campo de entrada _method:

<form action="/example" method="POST">
    @method('PUT')
    @csrf
</form>

#Acceso a la ruta actual

Puede usar los métodos current, currentRouteName y currentRouteAction en la fachada Route para acceder a información sobre la ruta que maneja la solicitud entrante:

use Illuminate\Support\Facades\Route;

$route = Route::current(); // Illuminate\Routing\Route
$name = Route::currentRouteName(); // string
$action = Route::currentRouteAction(); // string

Puede consultar la documentación API tanto para la clase subyacente de la fachada Route como para la instancia Route para revisar todos los métodos disponibles en las clases router y route.

#Compartición de recursos entre orígenes (CORS)

Laravel puede responder automáticamente a solicitudes HTTP CORS OPTIONS con los valores que usted configure. Todas las configuraciones CORS pueden configurarse en el archivo de configuración config/cors.php de su aplicación. Las solicitudes OPTIONS serán manejadas automáticamente por el middleware HandleCors middleware que se incluye por defecto en su pila global de middleware. Su pila global de middleware se encuentra en el kernel HTTP de su aplicación (App\Http\Kernel).

#Caché de rutas

Al desplegar su aplicación a producción, debe aprovechar la caché de rutas de Laravel. Usar la caché de rutas reducirá drásticamente el tiempo que toma registrar todas las rutas de su aplicación. Para generar una caché de rutas, ejecute el comando Artisan route:cache:

php artisan route:cache

Después de ejecutar este comando, su archivo de rutas en caché se cargará en cada solicitud. Recuerde, si agrega nuevas rutas necesitará generar una nueva caché de rutas. Por esta razón, debe ejecutar el comando route:cache solo durante el despliegue de su proyecto.

Puede usar el comando route:clear para limpiar la caché de rutas:

php artisan route:clear