This article elaborates on common errors and their correct practices when defining parameter routing in the Laravel framework. The core problem is that the parameters are written directly into the controller method name in the routing definition, which makes the system unable to find the corresponding method. The article will guide how to correctly configure routing to pass parameters to the controller, and emphasize the Laravel automatic parameter injection mechanism. It is also recommended to follow the RESTful specification to use the HTTP DELETE method in deletion operations to improve the professionalism and maintainability of the code.

In the Laravel framework, routing is the bridge between the application entry and the controller logic. Defining the route correctly, especially when it comes to parameter passing, is critical to building robust applications. This article will dig into common pitfalls when defining parameter routing and provide standard solutions and best practices.

Laravel routing and controller method association mechanism

Many beginners tend to incorrectly include parameter placeholders (for example, {id}) defined in the routing URI into the controller method name when defining GET routes with parameters. For example, use deleteData/{id} directly as the controller method name in the routing definition, as follows:

 // Incorrect routing definition example Route::get('', [AtributDashboardController::class, 'deleteData/{id}'])->name('deleteData');

When Laravel tries to resolve this route, it looks for a method named deleteData/{id} in the AtributDashboardController class. Since the actual method in the controller is named deleteData instead of deleteData/{id}, an error of Method App\Http\Controllers\Frontend\Atribut\AtributDashboardController::deleteData/{id} does not exist.

Correct understanding:

• The first parameter (string) in the route definition is the URI path, which defines the URL pattern requested by the client, which can contain parameter placeholders (such as {id}).
• The second parameter (array) in the routing definition specifies the controller class and method that handles the request. The controller method name here must be the method name that actually exists in the controller class and should not contain routing parameter placeholders.

Therefore, the correct way to define a GET route with parameter should be:

 // Example of correct route definition Route::get('deleteData/{id}', [AtributDashboardController::class, 'deleteData'])->name('deleteData');

Alternatively, if id is a unique identifier under the routing segment, it can be simplified to:

 // A more concise route definition example (in the current route group or path, id is the unique identifier)
Route::get('{id}', [AtributDashboardController::class, 'deleteData'])->name('deleteData');

In both cases, Laravel intelligently recognizes the {id} parameter in the URI and passes it as a parameter to the deleteData method in the AtributDashboardController class. The controller method signature should look like this:

 // Example of controller method namespace App\Http\Controllers\Frontend\Atribut;

use App\Http\Controllers\Controller;
use App\Models\InpData; // Suppose your model path class AtributDashboardController extends Controller
{
    protected $inpData;

    public function __construct(InpData $inpData) // Dependency injection model {
        $this->inpData = $inpData;
    }

    /**
     *Delete data based on ID*
     * @param int $id The data ID to delete
     * @return \Illuminate\Http\RedirectResponse
     */
    public function deleteData($id)
    {
        // Call the model method to perform the delete operation $this->inpData->deleteData($id);
        // Redirect back to the list page or related page return redirect('atribut/tabHome');
    }
}

In the above controller method, the $id variable will automatically receive the actual ID value passed in the route. The deletion logic in the model is usually as follows:

 // Model method example namespace App\Models;

use Illuminate\Support\Facades\DB;

class InpData
{
    /**
     * Delete a record from the database by ID*
     * @param int $id record ID to delete
     * @return int Number of deleted lines*/
    public function deleteData($id)
    {
        return DB::table('inp_datas')->where('id', $id)->delete();
    }
}

When generating a URL with parameters in a view file, you can use the route() helper function and pass the argument as a second parameter:

 {{-- Generate delete link in the view--}}
@forelse ($dataDisplay as $data)
  <tr>
   <td>{{ $data->name }}</td>
   <td>
     <a href="%7B%7B%20route('frontend.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

The route() helper function automatically builds the correct URL based on the defined route name frontend.atribut.tabHome.deleteData and the provided $data->id, such as /atribut/tabHome/deleteData/123.

Best Practice: Using HTTP DELETE Method

While using GET requests for deletion is technically feasible, this is not a best practice from a RESTful API design and HTTP semantics perspective. HTTP GET requests are usually used to obtain resources and should not cause changes in server state. The deletion operation will change the server state, so it is more suitable to use the HTTP DELETE method.

Advantages of using HTTP DELETE methods include:

• Semantic clarity: It clearly indicates that the intention of the operation is to delete the resource.
• Impotence: Perform deletion operations multiple times, the result is the same (the resource does not exist), and conforms to the principle of idempotence.
• Security: Avoid search engine crawlers or prefetching mechanisms accidentally trigger deletion operations.

The method of defining DELETE routing in Laravel is similar to GET:

 // Route definition using HTTP DELETE method Route::delete('deleteData/{id}', [AtributDashboardController::class, 'deleteData'])->name('deleteData');

Note: The tag in the browser only sends GET requests by default. To send a DELETE request, it usually needs to be done via form submission (with _method hidden fields) or JavaScript (AJAX).

Example view that simulates DELETE requests through a form:

 {{-- Send DELETE request through form in view--}}
@forelse ($dataDisplay as $data)
  <tr>
   <td>{{ $data->name }}</td>
   <td>
     <form action="%7B%7B%20route('frontend.atribut.tabHome.deleteData',%20%24data->id)%20%7D%7D" method="POST" style="display:inline;">
         @csrf {{-- CSRF protection to prevent cross-site request forgery--}}
         @method('DELETE') {{-- simulates the DELETE method, Laravel will recognize this hidden field--}}
         <button type="submit" class="btn btn-sm btn-danger">Delete</button>
     </form>
   </td>
  </tr>
@empty
  <tr><td colspan="2">No data</td></tr>
@endforelse

Summarize

When dealing with routing with parameters in Laravel, the core point is to distinguish the parameter placeholders in the routing URI from the name of the controller method itself. Ensure that the controller method name matches the actual method, and the parameters are automatically injected by Laravel. At the same time, in order to follow the RESTful specification and improve the robustness of the application, it is highly recommended to use the HTTP DELETE method when performing a deletion operation and send requests via form or AJAX instead of a simple GET link. Following these practices will help build clearer, more professional Laravel applications.

The above is the detailed content of Detailed explanation of Laravel routing parameter delivery and controller method definition. For more information, please follow other related articles on the PHP Chinese website!