Маршрутизация

• Основы маршрутизации
  • Маршруты перенаправления
  • Маршруты представлений
  • Список маршрутов
• Параметры маршрутов
  • Обязательные параметры
  • Необязательные параметры
  • Ограничения регулярными выражениями
• Именованные маршруты
• Группы маршрутов
  • Промежуточное ПО (middleware)
  • Контроллеры
  • Маршрутизация поддоменов
  • Префиксы маршрутов
  • Префиксы имён маршрутов
• Привязка моделей к маршрутам
  • Неявная привязка
  • Неявная привязка Enum
  • Явная привязка
• Запасные маршруты
• Ограничение частоты запросов
  • Определение ограничителей частоты
  • Привязка ограничителей частоты к маршрутам
• Подмена HTTP-методов в формах
• Доступ к текущему маршруту
• Кросс-доменные запросы (CORS)
• Кэширование маршрутов

#Основы маршрутизации

Самые простые маршруты Laravel принимают URI и замыкание, предоставляя очень простой и выразительный способ определения маршрутов и поведения без сложных конфигурационных файлов маршрутизации:

use Illuminate\Support\Facades\Route;

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

#Файлы маршрутов по умолчанию

Все маршруты Laravel определяются в файлах маршрутов, которые находятся в каталоге routes. Эти файлы автоматически загружаются провайдером App\Providers\RouteServiceProvider вашего приложения. Файл routes/web.php определяет маршруты для веб-интерфейса. Эти маршруты назначаются группе промежуточного ПО web, которая обеспечивает такие функции, как состояние сессии и защиту от CSRF. Маршруты в routes/api.php являются безсессионными и назначаются группе промежуточного ПО api.

В большинстве приложений вы начнёте с определения маршрутов в файле routes/web.php. Маршруты, определённые в routes/web.php, доступны по введённому в браузере URL. Например, вы можете получить доступ к следующему маршруту, перейдя по адресу http://example.com/user в браузере:

use App\Http\Controllers\UserController;

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

Маршруты, определённые в файле routes/api.php, вложены в группу маршрутов провайдером RouteServiceProvider. В этой группе автоматически применяется префикс URI /api, поэтому вам не нужно вручную добавлять его к каждому маршруту в файле. Вы можете изменить префикс и другие параметры группы маршрутов, изменив класс RouteServiceProvider.

#Доступные методы маршрутизатора

Маршрутизатор позволяет регистрировать маршруты, которые отвечают на любой 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);

Иногда может потребоваться зарегистрировать маршрут, который отвечает на несколько HTTP-методов. Это можно сделать с помощью метода match. Или вы можете зарегистрировать маршрут, который отвечает на все HTTP-методы, используя метод any:

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

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

#Внедрение зависимостей

Вы можете указать любые зависимости, необходимые вашему маршруту, в сигнатуре замыкания маршрута. Объявленные зависимости автоматически разрешаются и внедряются в замыкание с помощью service container Laravel. Например, вы можете указать класс Illuminate\Http\Request, чтобы текущий HTTP-запрос автоматически внедрялся в замыкание маршрута:

use Illuminate\Http\Request;

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

#Защита от CSRF

Помните, что любые HTML-формы, отправляющие запросы POST, PUT, PATCH или DELETE на маршруты, определённые в файле web, должны содержать поле с CSRF-токеном. В противном случае запрос будет отклонён. Подробнее о защите от CSRF можно прочитать в документации по CSRF:

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

#Маршруты перенаправления

Если вы определяете маршрут, который перенаправляет на другой URI, вы можете использовать метод Route::redirect. Этот метод предоставляет удобный ярлык, чтобы не создавать полноценный маршрут или контроллер для простого перенаправления:

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

По умолчанию Route::redirect возвращает код статуса 302. Вы можете изменить код статуса, используя необязательный третий параметр:

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

Или можно использовать метод Route::permanentRedirect для возврата кода состояния 301:

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

#Маршруты представлений

Если вашему маршруту нужно только вернуть view, вы можете использовать метод Route::view. Как и метод redirect, он предоставляет простой ярлык, чтобы не создавать полноценный маршрут или контроллер. Метод view принимает URI в качестве первого аргумента и имя представления — вторым. Кроме того, вы можете передать массив данных для передачи в представление в качестве необязательного третьего аргумента:

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

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

#Список маршрутов

Команда Artisan route:list позволяет легко получить обзор всех маршрутов, определённых в вашем приложении:

php artisan route:list

По умолчанию промежуточное ПО, назначенное каждому маршруту, не отображается в выводе route:list; однако вы можете заставить Laravel показывать промежуточное ПО и имена групп промежуточного ПО, добавив опцию -v к команде:

php artisan route:list -v

# Раскрыть группы middleware...
php artisan route:list -vv

Вы также можете указать Laravel показывать только маршруты, начинающиеся с заданного URI:

php artisan route:list --path=api

Кроме того, вы можете скрыть маршруты, определённые сторонними пакетами, указав опцию --except-vendor при выполнении команды route:list:

php artisan route:list --except-vendor

Аналогично, вы можете указать Laravel показывать только маршруты, определённые сторонними пакетами, указав опцию --only-vendor при выполнении команды route:list:

php artisan route:list --only-vendor

#Параметры маршрутов

#Обязательные параметры

Иногда нужно захватить сегменты URI в маршруте. Например, может потребоваться получить ID пользователя из URL. Это можно сделать, определив параметры маршрута:

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

Вы можете определить столько параметров маршрута, сколько требуется:

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

Параметры маршрута всегда заключаются в фигурные скобки {} и должны состоять из буквенных символов. Подчёркивания (_) также допустимы в именах параметров. Параметры маршрута внедряются в замыкания или контроллеры в порядке их следования — имена аргументов не имеют значения.

#Параметры и внедрение зависимостей

Если вашему маршруту нужны зависимости, которые вы хотите, чтобы Laravel автоматически внедрил в замыкание, указывайте параметры маршрута после зависимостей:

use Illuminate\Http\Request;

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

#Необязательные параметры

Иногда параметр маршрута может отсутствовать в URI. Это можно указать, добавив знак ? после имени параметра. Не забудьте задать переменной маршрута значение по умолчанию:

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

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

#Ограничения регулярными выражениями

Можно ограничить формат параметров маршрута с помощью метода where у экземпляра маршрута. Метод where принимает имя параметра и регулярное выражение, определяющее, как должен быть ограничен этот параметр:

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]+']);

Для удобства некоторые часто используемые шаблоны регулярных выражений имеют вспомогательные методы, позволяющие быстро добавить ограничения к маршрутам:

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']);

Если входящий запрос не соответствует ограничениям шаблона маршрута, будет возвращён HTTP-ответ с кодом 404.

#Глобальные ограничения

Если вы хотите, чтобы параметр маршрута всегда ограничивался заданным регулярным выражением, используйте метод pattern. Эти шаблоны следует определять в методе boot класса App\Providers\RouteServiceProvider:

/**
 * Определите привязки моделей маршрутов, фильтры шаблонов и т.д.
 */
public function boot(): void
{
    Route::pattern('id', '[0-9]+');
}

После определения шаблона он автоматически применяется ко всем маршрутам с этим именем параметра:

Route::get('/user/{id}', function (string $id) {
    // Выполняется только если {id} числовой...
});

#Кодированные прямые слэши

Компонент маршрутизации Laravel разрешает все символы, кроме /, в значениях параметров маршрута. Чтобы разрешить / в параметре, явно укажите это в регулярном выражении условия where:

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

#Именованные маршруты

Именованные маршруты позволяют удобно генерировать URL или перенаправления для конкретных маршрутов. Вы можете задать имя маршруту, вызвав метод name при определении маршрута:

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

Вы также можете задавать имена маршрутов для действий контроллеров:

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

#Генерация URL для именованных маршрутов

После присвоения имени маршруту вы можете использовать его при генерации URL или перенаправлений с помощью хелперов route и redirect:

// Генерация URL...
$url = route('profile');

// Генерация перенаправлений...
return redirect()->route('profile');

return to_route('profile');

Если именованный маршрут содержит параметры, вы можете передать их вторым аргументом функции route. Параметры автоматически подставятся в URL в нужных местах:

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

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

Если передать дополнительные параметры в массиве, они автоматически добавятся в строку запроса URL:

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

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

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

#Проверка текущего маршрута

Если нужно определить, был ли текущий запрос направлен к определённому именованному маршруту, можно использовать метод named у экземпляра маршрута. Например, проверка имени текущего маршрута в middleware:

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

/**
 * Обработка входящего запроса.
 *
 * @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);
}

#Группы маршрутов

Группы маршрутов позволяют совместно использовать атрибуты маршрутов, такие как middleware, для большого количества маршрутов без необходимости определять эти атрибуты для каждого маршрута отдельно.

Вложенные группы пытаются "сливать" атрибуты с родительской группой. Middleware и условия where объединяются, а имена и префиксы добавляются. Разделители пространства имён и слэши в префиксах URI добавляются автоматически, где это необходимо.

#Middleware

Чтобы назначить middleware всем маршрутам в группе, используйте метод middleware перед определением группы. Middleware выполняются в порядке, в котором они перечислены в массиве:

Route::middleware(['first', 'second'])->group(function () {
    Route::get('/', function () {
        // Используются first и second middleware...
    });

    Route::get('/user/profile', function () {
        // Используются first и second middleware...
    });
});

#Контроллеры

Если группа маршрутов использует один и тот же контроллер, можно использовать метод controller для определения общего контроллера для всех маршрутов группы. При определении маршрутов достаточно указать только метод контроллера, который они вызывают:

use App\Http\Controllers\OrderController;

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

#Маршрутизация поддоменов

Группы маршрутов также могут использоваться для маршрутизации поддоменов. Поддомены могут содержать параметры маршрута, как и URI маршрутов, что позволяет захватывать часть поддомена для использования в маршруте или контроллере. Поддомен задаётся вызовом метода domain перед определением группы:

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

#Префиксы маршрутов

Метод prefix позволяет добавить префикс URI ко всем маршрутам в группе. Например, можно добавить префикс admin ко всем маршрутам группы:

Route::prefix('admin')->group(function () {
    Route::get('/users', function () {
        // Совпадает с URL "/admin/users"
    });
});

#Префиксы имён маршрутов

Метод name позволяет добавить префикс к именам всех маршрутов в группе. Например, можно добавить префикс admin к именам всех маршрутов группы. Передаваемая строка добавляется к имени маршрута как есть, поэтому важно добавить завершающую точку . в префикс:

Route::name('admin.')->group(function () {
    Route::get('/users', function () {
        // Маршрут получает имя "admin.users"...
    })->name('users');
});

#Привязка моделей к маршрутам

При передаче ID модели в маршрут или действие контроллера часто требуется выполнить запрос к базе данных, чтобы получить соответствующую модель. Привязка моделей к маршрутам Laravel позволяет автоматически внедрять экземпляры моделей прямо в маршруты. Например, вместо передачи ID пользователя можно внедрить весь экземпляр модели User, соответствующий этому ID.

#Неявная привязка

Laravel автоматически разрешает модели Eloquent, определённые в маршрутах или действиях контроллеров, если имена переменных с типами совпадают с именем сегмента маршрута. Например:

use App\Models\User;

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

Поскольку переменная $user типизирована как модель App\Models\User и имя переменной совпадает с сегментом URI {user}, Laravel автоматически внедрит экземпляр модели с ID, соответствующим значению из URI. Если модель не найдена, автоматически возвращается HTTP-ответ 404.

Неявная привязка также работает с методами контроллеров. Обратите внимание, что сегмент URI {user} совпадает с переменной $user в контроллере, которая типизирована как App\Models\User:

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

// Определение маршрута...
Route::get('/users/{user}', [UserController::class, 'show']);

// Определение метода контроллера...
public function show(User $user)
{
    return view('user.profile', ['user' => $user]);
}

#Модели с мягким удалением

По умолчанию неявная привязка не извлекает модели, которые были мягко удалены. Однако вы можете указать неявной привязке извлекать такие модели, вызвав метод withTrashed при определении маршрута:

use App\Models\User;

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

#Настройка ключа

Иногда нужно разрешать модели Eloquent по столбцу, отличному от id. Для этого укажите столбец в определении параметра маршрута:

use App\Models\Post;

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

Если вы хотите, чтобы привязка модели всегда использовала столбец, отличный от id, переопределите метод getRouteKeyName в модели Eloquent:

/**
 * Получить ключ маршрута для модели.
 */
public function getRouteKeyName(): string
{
    return 'slug';
}

#Пользовательские ключи и область действия

При неявной привязке нескольких моделей Eloquent в одном маршруте можно ограничить вторую модель как дочернюю по отношению к первой. Например, маршрут, который получает блог-пост по slug для конкретного пользователя:

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

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

При использовании пользовательского ключа в неявной привязке для вложенного параметра Laravel автоматически ограничит запрос, чтобы получить вложенную модель через родительскую, используя соглашения для определения имени связи на родителе. В данном случае предполагается, что у модели User есть связь posts (множественное число имени параметра маршрута), которая используется для получения модели Post.

Если хотите, вы можете заставить Laravel ограничивать "дочерние" привязки даже без пользовательского ключа, вызвав метод scopeBindings при определении маршрута:

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

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

Или можно указать целой группе маршрутов использовать ограниченные привязки:

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

Аналогично, можно явно запретить Laravel использовать ограниченные привязки, вызвав метод withoutScopedBindings:

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

#Настройка поведения при отсутствии модели

Обычно при отсутствии модели, связанной неявно, возвращается HTTP-ответ 404. Тем не менее, вы можете настроить это поведение, вызвав метод missing при определении маршрута. Метод missing принимает замыкание, которое будет вызвано, если не удаётся найти модель, связанную неявно:

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');
        });

#Неявная привязка Enum

PHP 8.1 добавил поддержку Enum. Laravel позволяет типизировать параметр маршрута как строковый Enum, и маршрут будет вызван только если сегмент соответствует допустимому значению Enum. В противном случае автоматически возвращается HTTP-ответ 404. Например, для следующего Enum:

<?php

namespace App\Enums;

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

Вы можете определить маршрут, который будет вызван только если сегмент {category} равен fruits или people. В противном случае Laravel вернёт HTTP-ответ 404:

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

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

#Явная привязка

Вы не обязаны использовать неявное разрешение моделей Laravel для привязки. Можно явно определить, как параметры маршрута соответствуют моделям. Для регистрации явной привязки используйте метод model маршрутизатора, указав класс для параметра. Явные привязки следует определять в начале метода boot класса RouteServiceProvider:

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

/**
 * Определите привязки моделей маршрутов, фильтры шаблонов и т.д.
 */
public function boot(): void
{
    Route::model('user', User::class);

    // ...
}

Далее определите маршрут с параметром {user}:

use App\Models\User;

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

Поскольку все параметры {user} связаны с моделью App\Models\User, в маршрут будет внедрён экземпляр этой модели. Например, запрос к users/1 внедрит экземпляр User с ID 1.

Если соответствующая модель не найдена, автоматически возвращается HTTP-ответ 404.

#Настройка логики разрешения

Если хотите определить собственную логику разрешения привязки модели, используйте метод Route::bind. Замыкание, переданное в bind, получит значение сегмента URI и должно вернуть экземпляр класса для внедрения в маршрут. Это настраивается в методе boot класса RouteServiceProvider:

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

/**
 * Определите привязки моделей маршрутов, фильтры шаблонов и т.д.
 */
public function boot(): void
{
    Route::bind('user', function (string $value) {
        return User::where('name', $value)->firstOrFail();
    });

    // ...
}

Альтернативно, можно переопределить метод resolveRouteBinding в модели Eloquent. Этот метод получает значение сегмента URI и должен вернуть экземпляр класса для внедрения:

/**
 * Получить модель для связанного значения.
 *
 * @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();
}

Если маршрут использует ограничение области неявной привязки, метод resolveChildRouteBinding будет использоваться для разрешения дочерней привязки родительской модели:

/**
 * Получить дочернюю модель для связанного значения.
 *
 * @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);
}

#Запасные маршруты

С помощью метода Route::fallback можно определить маршрут, который будет выполнен, если ни один другой маршрут не совпадает с входящим запросом. Обычно необработанные запросы автоматически отображают страницу "404" через обработчик исключений приложения. Однако поскольку fallback обычно определяется в файле routes/web.php, к маршруту применяются все middleware группы web. Вы можете добавить дополнительные middleware к этому маршруту при необходимости:

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

#Ограничение частоты запросов

#Определение ограничителей частоты

Laravel включает мощные и настраиваемые сервисы ограничения частоты, которые можно использовать для ограничения количества трафика для конкретного маршрута или группы маршрутов. Для начала следует определить конфигурации ограничителей частоты, соответствующие потребностям вашего приложения.

Обычно ограничители частоты определяются в методе boot класса App\Providers\RouteServiceProvider. В этом классе уже есть определение ограничителя, применяемого к маршрутам в файле routes/api.php вашего приложения:

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

/**
 * Определите привязки моделей маршрутов, фильтры шаблонов и другую конфигурацию маршрутов.
 */
protected function boot(): void
{
    RateLimiter::for('api', function (Request $request) {
        return Limit::perMinute(60)->by($request->user()?->id ?: $request->ip());
    });

    // ...
}

Ограничители частоты запросов определяются с помощью метода for фасада RateLimiter. Метод for принимает имя ограничителя и замыкание, которое возвращает конфигурацию лимита, применяемую к маршрутам, назначенным этому ограничителю. Конфигурации лимитов — это экземпляры класса Illuminate\Cache\RateLimiting\Limit. Этот класс содержит удобные методы-помощники, позволяющие быстро задать лимит. Имя ограничителя может быть любой строкой:

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

/**
 * Определите привязки моделей маршрутов, фильтры шаблонов и другую конфигурацию маршрутов.
 */
protected function boot(): void
{
    RateLimiter::for('global', function (Request $request) {
        return Limit::perMinute(1000);
    });

    // ...
}

Если входящий запрос превышает указанный лимит, Laravel автоматически возвращает ответ с HTTP-статусом 429. Если хотите определить собственный ответ при превышении лимита, используйте метод response:

RateLimiter::for('global', function (Request $request) {
    return Limit::perMinute(1000)->response(function (Request $request, array $headers) {
        return response('Пользовательский ответ...', 429, $headers);
    });
});

Поскольку колбэки ограничителей получают входящий HTTP-запрос, вы можете динамически строить лимит в зависимости от запроса или аутентифицированного пользователя:

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

#Сегментация лимитов

Иногда нужно сегментировать лимиты по произвольному значению. Например, разрешить пользователям обращаться к маршруту 100 раз в минуту с одного IP. Для этого используйте метод by при построении лимита:

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

Другой пример: ограничить доступ к маршруту 100 раз в минуту для аутентифицированных пользователей по ID и 10 раз в минуту для гостей по IP:

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

#Несколько лимитов

При необходимости можно вернуть массив лимитов для одного ограничителя. Каждый лимит будет проверяться в порядке следования в массиве:

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

#Привязка ограничителей частоты к маршрутам

Ограничители частоты запросов можно прикрепить к маршрутам или группам маршрутов с помощью throttle middleware. Middleware throttle принимает имя ограничителя частоты запросов, которое вы хотите назначить маршруту:

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

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

#Ограничение с Redis

Обычно middleware throttle сопоставлен с классом Illuminate\Routing\Middleware\ThrottleRequests в HTTP-ядре приложения (App\Http\Kernel). Однако если вы используете Redis в качестве драйвера кэша, можно изменить сопоставление на класс Illuminate\Routing\Middleware\ThrottleRequestsWithRedis. Этот класс эффективнее управляет ограничением частоты с Redis:

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

#Подмена HTTP-методов в формах

HTML-формы не поддерживают действия PUT, PATCH или DELETE. Поэтому при определении маршрутов PUT, PATCH или DELETE, которые вызываются из HTML-формы, нужно добавить в форму скрытое поле _method. Значение, отправленное в поле _method, будет использовано как HTTP-метод запроса:

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

Для удобства вы можете использовать @method директиву Blade для генерации поля ввода _method:

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

#Доступ к текущему маршруту

Вы можете использовать методы current, currentRouteName и currentRouteAction фасада Route для получения информации о маршруте, обрабатывающем текущий запрос:

use Illuminate\Support\Facades\Route;

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

Вы можете ознакомиться с документацией API для класса фасада Route и экземпляра Route, чтобы изучить все доступные методы маршрутизатора и маршрута.

#Кросс-доменные запросы (CORS)

Laravel автоматически отвечает на CORS OPTIONS HTTP-запросы значениями, которые вы настроите. Все настройки CORS можно задать в конфигурационном файле приложения config/cors.php. Запросы OPTIONS автоматически обрабатывает HandleCors middleware, который по умолчанию включён в ваш глобальный стек middleware. Глобальный стек middleware находится в HTTP-ядре вашего приложения (App\Http\Kernel).

#Кэширование маршрутов

При развертывании приложения в продакшн рекомендуется использовать кэш маршрутов Laravel. Кэширование значительно сокращает время регистрации всех маршрутов приложения. Для создания кэша маршрутов выполните команду Artisan route:cache:

php artisan route:cache

После выполнения этой команды файл кэшированных маршрутов будет загружаться при каждом запросе. Помните, что при добавлении новых маршрутов нужно создавать новый кэш маршрутов. Поэтому команду route:cache следует запускать только при развертывании проекта.

Для очистки кэша маршрутов используйте команду route:clear:

php artisan route:clear