In Laravel, routing is the entry point of the application that defines the response logic when a client requests a specific URI. The route maps the URL to the corresponding processing code, which usually contains HTTP methods, URIs, and actions (closures or controller methods). 1. Basic structure of route definition: bind requests using Route::verb('/uri', action); 2. Supports multiple HTTP verbs such as GET, POST, PUT, etc.; 3. Dynamic parameters can be defined through {param} and data can be passed; 4. The route can be named to generate URLs or redirects; 5. Use the grouping function to uniformly add prefixes, middleware and other sharing settings; 6. Routing files are divided into web.php, api.php, console.php and channels.php according to their purpose, corresponding to different scenarios.

In Laravel, routes are essentially the entry points to your application — they define how your app responds to a client request at a specific URI. Think of them as the mapping between URLs and the code that handles them.

Basic Concept: What Are Routes?

At their core, routes in Laravel determine what happens when someone visits a certain URL on your site. For example, if you have a blog, visiting /posts might show a list of posts, while /posts/1 shows a specific one. Each of these URLs is tied to a route that tells Laravel where to go and what to do.

You define routes in files inside the routes directory. The most common ones are:

• web.php – for regular HTML pages (with session state, CSRF protection, etc.)
• api.php – for stateless APIs
• console.php – for Artisan commands
• channels.php – for broadcast channels

Each route typically includes an HTTP verb (like GET or POST), a URI, and an action (a controller method or closure).

Defining Simple Routes

The simplest way to define a route is using a closure directly in your route file. Here's an example from routes/web.php :

 Route::get('/hello', function () {
    return 'Hello, Laravel!';
});

This means when someone accesses /hello via a GET request, Laravel will return "Hello, Laravel!".

You can also use controller methods instead of closings, which keeps your route files clean and separates concerns:

 Route::get('/posts', [PostController::class, 'index']);

Here, accessing /posts will call the index method of PostController .

Some other common HTTP verbs include:

• Route::post() – for form submissions
• Route::put() – for updates
• Route::delete() – for deletions
• Route::patch() – partial updates

Route Parameters: Passing Data Through URLs

If you need to pass dynamic data through a URL (like a user ID or post slug), Laravel makes it easy with route parameters.

For example:

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

Now, visiting /user/123 would display "User ID: 123".

You can have multiple parameters too:

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

These parameters can also be optional by giving them a default value:

 Route::get('/page/{number?}', function ($number = 1) {
    return "Page number: $number";
});

Naming and Grouping Routes

As your app grows, naming routes become super useful — especially when generating URLs or redirects.

 Route::get('/about', function () {
    return view('about');
})->name('about.page');

Then later, you can reference it like this:

 route('about.page');

Grouping routes helps organize shared logic, such as middleware or prefixes:

 Route::prefix('admin')->group(function () {
    Route::get('/dashboard', function () {
        return 'Admin Dashboard';
    })->name('admin.dashboard');

    Route::get('/users', function () {
        return 'Admin Users';
    })->name('admin.users');
});

This way, all routes under the group have /admin prepended automatically.

Middleware can also be applied to a group:

 Route::middleware(['auth'])->group(function () {
    Route::get('/profile', function () {
        return 'Your Profile';
    });
});

This ensures only authenticated users can access those routes.

That's the general idea of ??how routing works in Laravel. It gives you a lot of flexibility without being overly complex once you get the hang of it.

The above is the detailed content of What are routes in Laravel, and how are they defined?. For more information, please follow other related articles on the PHP Chinese website!