View routing

If your route only needs to return a view, you can use the Route::view method. It's just as convenient as redirect and doesn't require defining full routes or controllers. view The method has three parameters, the first of which is a required parameter and is the URI containing the view name. The second and required parameter is the name of the view that needs to be rendered. The third parameter is an optional parameter. You can pass in an array, and the data in the array will be passed to the view:

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

Route Parameters

Required Parameters

Of course, sometimes you need to capture some URL fragments in the route. For example, to capture the user's ID from the URL, you can do this by defining route parameters:

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

You can also define multiple parameters in the route as needed:

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

The parameters of the route are usually will be placed within {}, and parameter names can only be letters. At the same time, routing parameters cannot contain - symbols. Underlines (_) can be used if necessary. replace. Route parameters will be injected into route callbacks or controllers in order, regardless of the parameter names of the callbacks or controllers.

Optional Parameters

Sometimes, you may need to specify a routing parameter, but you want this parameter to be available Chosen. You can add the ? tag after the parameter to achieve this, but the premise is to ensure that the corresponding variable of the route has a default value

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

Regular Expression Constraints

You can constrain the format of route parameters using the where method on a route instance. where The method accepts a parameter name and a regular expression that defines how the parameter should be constrained:

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

Global constraint

If you want a specific Routing parameters all follow the constraints of the same regular expression. Use the pattern method to define these patterns in the boot method of RouteServiceProvider:

/**
 * 定义你的路由模型绑定, pattern 过滤器等。
 *
 * @return void
 */
 public function boot(){
     Route::pattern('id', '[0-9]+');    
     parent::boot();
  }

Once defined, these rules will be automatically applied to all routes using this parameter name:

Route::get('user/{id}', function ($id) { 
   // 只有在 id 为数字时才执行。
 });

Encoded forward slash characters

Laravel routing components allow All characters except /. You must explicitly allow / to be part of the placeholder using a where conditional regex:

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

Note: encoded forward slash character only in the last It is supported in routing segments.

Route naming

Route naming can easily generate URLs or redirects for specified routes. You can specify the route name by chaining the name method on the route definition:

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

You can also specify the route name of the controller action:

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

Generate the URL of the specified route

After specifying a name for the route, you can use the global auxiliary function route to generate a link or redirect to the route:

// 生成 URL...
$url = route('profile');
// 生成重定向...
return redirect()->route('profile');

If it is a named route with defined parameters, you can pass the parameters as the second parameter of the route function, and the specified parameters will be automatically inserted into the corresponding position in the URL:

Route::get('user/{id}/profile', function ($id) {
    //
 })->name('profile');
 $url = route('profile', ['id' => 1]);

Check the current route

If you want to determine whether the current request points to a certain route, you can call the named method on the routing instance. For example, you can check the current route name in the routing middleware:

/**
 * 处理一次请求。
 *
 * @param  \Illuminate\Http\Request  $request
 * @param  \Closure  $next
 * @return mixed
 */
 public function handle($request, Closure $next){
     if ($request->route()->named('profile')) {    
         //  
        } 
    return $next($request);
 }

routing group

routing group allowed You share route properties, such as middleware or namespaces, across a large number of routes without defining these properties individually for each route. Shared attributes should be passed into the first parameter of the Route::group method in the form of an array.

Middleware

To assign middleware to all routes in a routing group, you can call it before groupmiddleware method, middleware will be run in the order they are listed in the array:

Route::middleware(['first', 'second'])->group(function () { 
   Route::get('/', function () { 
       // // 使用 first 和 second 中间件  
       });
    Route::get('user/profile', function () {  
       // // 使用 first 和 second 中间件
        });
    });

Namespace

Another common use case is to assign the same PHP namespace to all controllers in a routing group using the namespace method:

Route::namespace('Admin')->group(function () {  
  // 在 "App\Http\Controllers\Admin" 命名空间下的控制器
 });

Remember that by default Next, RouteServiceProvider will introduce your route file in the namespace group, allowing you to register controller routes without specifying the complete App\Http\Controllers namespace prefix. Therefore, you only need to specify the part after the namespace App\Http\Controllers.

Subdomain name routing

Routing groups can also be used to handle subdomain names. Subdomains can be assigned route parameters just like route URIs, allowing you to get a portion of the subdomain as parameters for a route or controller. You can call the domain method before group to specify a subdomain name:

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

Routing prefix

You can use the prefix method to add a prefix to the URL given in the routing group. For example, you can prefix the URIs of all routes in the group with admin:

Route::prefix('admin')->group(function () { 
   Route::get('users', function () {   
        // 匹配包含 "/admin/users" 的 URL  
       });
   });

Route name prefix

The name method can be used to add a given string to each route name in the routing group. For example, you might want to prefix the names of all group routes with "admin." The given string is exactly the same as the specified route name prefix, so we will make sure to provide the trailing . characters in the prefix:

Route::name('admin.')->group(function () { 
   Route::get('users', function () {   
        // 指定路由名为 "admin.users"...  
   })->name('users');});

Route model binding

When injecting a model ID into a route or controller behavior, you need to query the model corresponding to this ID. Laravel provides a way for route model binding to directly and automatically inject model instances into routes. For example, instead of injecting the user's ID, you can inject the entire User model instance that matches a given ID.

Implicit binding

Laravel will automatically parse the type hints defined in routes or controller actions. The variable name matches the route segment name of the Eloquent model. For example:

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

In this example, since the $user variable is type-hinted to the Eloquent model App\User, the variable name is the same as the in the URI. {user} matches, so Laravel automatically injects a user model instance that matches the ID passed in the request URI. If the corresponding model instance cannot be found in the database, a 404 exception will be automatically generated.

Custom key name

If you want model binding to use a database other than id when retrieving the given model class Field, you can override the getRouteKeyName method on the Eloquent model:

/**
 * 获取该模型的路由的自定义键名。
 *
 * @return string
 */
 public function getRouteKeyName(){
     return 'slug';
  }

model method to specify the class for the given parameter. Define these explicit model bindings within the boot method in the RouteServiceProvider class:

public function boot(){
    parent::boot();
    Route::model('user', App\User::class);
  }

{user} Route for:

Route::get('profile/{user}', function (App\User $user) { 
   //
 });

{user} parameters to the App\User model, the User instance will be Inject this route. For example, a request for profile/1 will inject the User instance with ID 1 in the database.

/**
 * 启动应用服务。
 *
 * @return void
 */
 public function boot(){
         parent::boot();        
         Route::bind('user', function ($value) {          
               return App\User::where('name', $value)->first() ?? abort(404);   
               });
    }

/**
 * 检索绑定值的模型。
 *
 * @param  mixed  $value
 * @return \Illuminate\Database\Eloquent\Model|null
 */
 public function resolveRouteBinding($value){ 
    return $this->where('name', $value)->first() ?? abort(404);
 }

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

Route::middleware('auth:api', 'throttle:60,1')->group(function () { 
   Route::get('/user', function () { 
          //   
       });
  });

Route::middleware('auth:api', 'throttle:rate_limit,1')->group(function () {
    Route::get('/user', function () {  
          //  
      });
  });

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

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

$route = Route::current();
$name = Route::currentRouteName();
$action = Route::currentRouteAction();