This article discusses the correct posture for parameter transfer of controller methods in Laravel routing in depth. In response to common errors caused by writing routing parameters directly to the controller method name, the correct routing definition syntax is explained in detail, and the mechanism of Laravel automatic parameter binding is emphasized. At the same time, the article recommends using HTTP DELETE method that is more RESTful specification-compliant HTTP DELETE to handle deletion operations to improve the maintainability and semantics of the application.

Understand the correct binding of Laravel routing and controller methods

In the Laravel framework, Routes is the entry point of the application, which is responsible for mapping incoming HTTP requests to specific controller methods for execution. A typical route definition contains the requested URI, HTTP methods, and corresponding controller classes and methods. The key is that the controller method name should be a pure PHP method name and should not contain any URI parameter placeholders. Parameters in the URI (such as {id}) should be defined as part of the path, and Laravel's routing system intelligently parses these parameters and passes them as parameters to the corresponding controller method.

Common error analysis: The root cause of the method not exists

When defining routes with parameters, developers sometimes mistakenly write the URI parameter placeholder directly into the controller method name, causing Laravel to be unable to find the corresponding method. For example, the following route definition is wrong:

 Route::group([
  'prefix' => 'atribut',
  'as' => 'atribut.'
], function () {
  Route::group(['prefix' => 'tabHome', 'as' => 'tabHome.'], function () {
    // Error example: Write {id} to the method name Route::get('', [AtributDashboardController::class, 'deleteData/{id}'])->name('deleteData');
  });
});

When Laravel tries to parse deleteData/{id} as a controller method, it looks for a PHP method named deleteData/{id} in the AtributDashboardController class. However, deleteData/{id} is not a legitimate PHP method name (PHP method name cannot contain special characters such as / or {}), so Laravel throws an error with Method ...::deleteData/{id} does not exist.

The core reason is that: The URI parameter is part of the routing path, not part of the controller method name. The controller method name only specifies the function to be executed, and the passing of parameters is automatically done by Laravel's routing matching mechanism.

Correct routing parameter delivery practice

To correctly define a route with parameters, the parameter placeholder {id} needs to be placed in the URI part of the route, while the controller method name maintains its pure PHP method name.

1. Routing definition : Place the parameter {id} in the URI and make sure the controller method name is a valid PHP method name.

    // routes/web.php or api.php
   Route::group([
     'prefix' => 'atribut',
     'as' => 'atribut.'
   ], function () {
     Route::group(['prefix' => 'tabHome', 'as' => 'tabHome.'], function () {
       // Correct example: Take {id} as part of the URI path Route::get('deleteData/{id}', [AtributDashboardController::class, 'deleteData'])->name('deleteData');
   
       // Or, if {id} is a unique identifier for the path segment, it can also be simplified to:
       // Route::get('{id}', [AtributDashboardController::class, 'deleteData'])->name('deleteData');
     });
   });

2. Controller method : The controller method only needs to declare a parameter corresponding to the URI parameter placeholder name (for example, $id), and Laravel will automatically pass the value captured in the URI to this parameter.

    // app/Http/Controllers/Frontend/Atribut/AtributDashboardController.php
   namespace App\Http\Controllers\Frontend\Atribut;
   
   use App\Http\Controllers\Controller;
   // ... Other necessary use statements, such as use Illuminate\Http\Request;
   
   class AtributDashboardController extends Controller
   {
       protected $inpData; // Assume public function __construct(/* YourServiceClass $inpData */) is available through constructor injection or other methods
       {
           // $this->inpData = $inpData;
       }
   
       /**
        * Process requests to delete data.
        *
        * @param int $id The data ID to delete
        * @return \Illuminate\Http\RedirectResponse
        */
       public function deleteData($id)
       {
           // Laravel will automatically match the {id} value in the URI to the $id parameter $this->inpData->deleteData($id); // Call the model or service layer for actual deletion return redirect('atribut/tabHome'); // Redirect to list page}
   }

3. View layer call : When generating a URL with parameters in a Blade template, use the route() helper function and pass in the corresponding parameter value.

    {{-- resources/views/your_view.blade.php --}}
   @forelse ($dataDisplay as $data)
     <tr>
      <td>{{ $data->name }}</td>
      <td>
        <a href="%7B%7B%20route('atribut.tabHome.deleteData',%20%24data->id)%20%7D%7D" class="btn btn-sm btn-danger">Delete</a>
      </td>
     </tr>
   @empty
     <tr><td colspan="2">No data</td></tr>
   @endforelse

   Here route('atribut.tabHome.deleteData', $data->id) will generate a URL similar to /atribut/tabHome/deleteData/1, where 1 is the actual value of $data->id.

Best Practice: Using HTTP DELETE Method

From a RESTful architectural style perspective, the operation to delete a resource should use the HTTP DELETE method instead of GET or POST. This makes the interface more semantic and predictable.

1. Defining a DELETE route : Laravel provides the Route::delete() method to define the route for a DELETE request.

    // routes/web.php or api.php
   Route::group([
     'prefix' => 'atribut',
     'as' => 'atribut.'
   ], function () {
     Route::group(['prefix' => 'tabHome', 'as' => 'tabHome.'], function () {
       // Recommended: Use the DELETE method to handle the deletion operation Route::delete('deleteData/{id}', [AtributDashboardController::class, 'deleteData'])->name('deleteData');
     });
   });

2. The front-end sends DELETE request : HTML forms natively only support GET and POST methods. To send a DELETE request, Laravel provides a @method Blade directive that generates a hidden _method field in the form, which Laravel recognizes and treats as the specified HTTP method.

    {{-- resources/views/your_view.blade.php --}}
   @forelse ($dataDisplay as $data)
     <tr>
      <td>{{ $data->name }}</td>
      <td>
        <form action="%7B%7B%20route('atribut.tabHome.deleteData',%20%24data->id)%20%7D%7D" method="POST" style="display:inline;">
            @csrf {{-- Cross-site request forgery protection--}}
            @method('DELETE') {{-- Simulated DELETE request--}}
            <button type="submit" class="btn btn-sm btn-danger" onclick="return confirm('Are you sure you want to delete this item?');">Delete</button>
        </form>
      </td>
     </tr>
   @empty
     <tr><td colspan="2">No data</td></tr>
   @endforelse

   In this way, when the user clicks the delete button, the form is submitted as a POST request, but Laravel routes it to a DELETE route based on the _method field.

Summarize

It is crucial to correctly understand the mapping relationship between URI parameters and controller method parameters in Laravel routing. The core points are:

• The URI parameter placeholder (such as {id}) is part of the routing URI and is used to define the URL pattern.
• The controller method name is a pure PHP method name and does not contain any URI parameter information.
• Laravel will automatically pass the parameter values captured in the URI in order or through parameter names to the corresponding parameters of the controller method.
• For deletion operations, it is highly recommended to use the HTTP DELETE method to define the route and send requests on the front end in conjunction with Laravel Blade's @method('DELETE') directive to follow RESTful best practices to improve the semantics and maintainability of the code.

The above is the detailed content of Laravel routing parameter passing: correctly define the controller method and routing binding. For more information, please follow other related articles on the PHP Chinese website!