DEV Community

loading...

All you need to know about Route in Laravel 5

kris profile image kris Originally published at Medium on ・9 min read

All you need to know about Route in Laravel 5

Route explanation

In a Laravel , provide handle multiple route type we have “web” routes in routes/web.php and “API” routes in routes/api.php and artisan command route in console.php. Web routes are those that will be visited by users; API routes are those for your API. For this post, we’ll focus on the routes in routes/web.php.

Basic route definition

all class in laravel declare by static way and we pass parameter in key-value format; value can use in multiple type in example we use closure style

// routes/web.php 
Route::get('/', function () {       
        return 'Hello, World!';
});

WHAT’S A CLOSURE?

closure is an object representation of an anonymous function. We can see that the anonymous function in the above code actually returns an object of closure which is assigned to and called using the variable $string. You can say closure is an object oriented way to use anonymous functions.

why use static class

If you have much experience developing PHP, you might be surprised to see static calls on the Route class. This is not actually a static method , but rather service location using Laravel’s facades

but if you don’t like facade this alternative way

$router->get('/', function () {
    return 'Hello, World!';
 });

Route Verbs

You might’ve noticed that we’ve been using Route::get in our route definitions. This means we’re telling Laravel to only match for these routes when the HTTP request uses the GET action. But what if it’s a form POST, or maybe some JavaScript sending PUT or DELETE requests? There are a few other options for methods to call on a route definition,

Route::get('/', function () { 
return 'Hello, World!'; 
});
Route::post('/', function () {});
Route::put('/', function () {});
Route::delete('/', function () {});
Route::any('/', function () {})
Route::match(['get', 'post'], '/', function () {});

HTTP METHODS

If you’re not familiar with the idea of HTTP methods, read on in this

Route Handling

closure doesn’t only way for resolve route action, We can bridge to controller with this example

Route::get('/user/list', 'UserController@list');

This is telling Laravel to pass requests to that path to the list() method of the App\Http\Controllers\UserController controller. This method will be passed the same parameters and treated the same way as a closure.

Route Parameters

If the route has parameters segments in the URL structure that are variable it’s simple to define them in your route and pass them to your closure

Route::get('users/{id}/list', function ($id) { 
// 
});

we use {id} for accept parameter and $id use to pass parameter to closure but if we didn’t pass parameter we get error

We can also make your route parameters optional by including a question mark (?) after the parameter name, like this

Route::get('users/{id?}/list', function ($id = 'fallbackId') { 
//
 });

And you can use regular expressions to define that a route should only match if a parameter meets particular requirements

Route::get('users/{id}', function ($id) { 
//
 })->where('id', '[0-9]+');

if you visit a path that matches a route string, but the regex doesn’t match the parameter, it won’t be matched, so it would return a 404 Not Found error.

Route Names

if we need to use route in elsewhere your can refer by url path and put in parameter to url() helper to simplify that linking in your views, in below example . The helper will prefix your route with the full domain of your site.

<a href="<?php echo url('/'); ?>"> // outputs <a href="http://yoursite.com/">

in previous version laravel give name to route with alias method but now this change to name method but give same feature you can call route without use full path and when change url you doesn’t change all place .

// in routes/web.php: 
Route::get('user/{id}', 'UsersController@show')->name('user.show');
// Link the route in a view with route() helper
 <a href="<?php echo route('user.show'); ?>">

This example show a few new concepts. First, we’re using fluent route definition to add the name, by chaining the name() method . This method allows us to name the route, make it a short alias to use it dynamically and can reference elsewhere.

Passing route parameters to helper

When your route has parameters (e.g., posts/{id}), you need to define those parameters when you’re using the route() helper to generate a link to the route.

There are a few different ways to pass these parameters. Let’s imagine a route defined as posts/{postId}/comments/{commentId}. If the user ID is 3 and the comment ID is 7, let’s look at a few options we have available to us:

Option 1:

route('posts.comments.show', [3, 7]) 
// http://yoursite.com/posts/3/comments/7
route('posts.comments.show', ['postId' => 3, 'commentId' => 7]) 
// http://yoursite.com/posts/3/comments/7
// tips to pass query string
route('users.comments.show', ['postId' => 3, 'commentId' => 7, 'opt' => 'a']) 
// http://myapp.com/posts/1/comments/2?opt=a

Route Groups

if you have a routes share a certain authentication , a path prefix, or a controller namespace. if we defined shared characteristics again and again on each route not only seems boring task and make you application not organize.

But route groups allow you to group several routes together, and apply any shared configuration settings once, to reduce this duplication.

this example show how to group route with route group

Route::group([], function () {          
   Route::get('Hi', function () {            
      return 'taq';         
   });        
   Route::get('world', function () {         
         return 'World';
  });
});

By default, a route group doesn’t actually do anything. Besides we will pass some configuration to first parameter (eg. middleware,prefix,namespace)

Route group and Middleware

middleware is some configuration that we want to do before or after visitor access to route (eg.authentication,checkage) in this case we apply middleware name auth for check visitor access this group has authenticate user if you doesn’t authenticate can’t access dashboard or user profile

Route::group(['middleware' => 'auth'], function () { 
     Route::get('dashboard', function () {
       return view('dashboard');     
     });      
     Route::get('profile', function () {   
       return view('profile');    
     }); 
});

Route group and path prefixes

If you have a group of routes that share a segment of their path for example, if your site’s admin area is prefixed with /adminyou can use route groups to do that

Route::group(['prefix' => 'admin'], function () { 
        Route::get('/', function () {
           // Handles the path /admin 
         }); 
         Route::get('users', function () {
           // Handles the path /admin/users 
          }); 
});

Route group and namespace Prefixes

If you’re grouping routes by path prefix, it’s similar their controllers have a similar PHP namespace. In the Admin example, all of the Admin routes’ controllers might be under an Admin namespace. By using the route group namespace prefix, as in example, help we avoid long controller references

// not use route group
 Route::get('/report', 'Admin/ReportControllerB@index');      
 Route::get('/setting', 'Admin/SettingControllerB@index');
Route::group(['namespace' => 'Admin'], function () {

    Route::get('/report', 'ReportControllerB@index');      
    Route::get('/setting', 'SettingControllerB@index');
});

Name Prefixes

you can also set prefix to name() function with ‘as’ example

Route::group(['as' => 'posts.', 'prefix' => 'posts'], function () {     
  Route::group(['as' => 'comments.', 'prefix' => 'comments'], function () {     
  // you can use by in helper like route('posts.comments.list')               
  Route::get('{id}', function () { // })->name('list'); });
 });

Route and Views

You can render view directly in controller in three different ways . For now, just concern yourself with view(), it’s helper function.

first way use closure

Route::get('/', function () { 
return view('home'); 
});

this closure loads the resources/views/home.blade.php

second way pass parameter

Route::get('users', function () {     
    return view('users.index')->with('users', User::all());
});

This closure loads the resources/views/users/index.blade.php and passes it a single variable named tasks, which contains the result of the User::all() method.

third way using View Composers to Share Variables with Every View Sometimes it can become a duplicate to pass the same variables over and over. There may be a variable that you want accessible to every view in the site.

view()->share('user','somevalue');

Route and Controllers

Route is gate between controllers and views, in this section we talk about how many way to use route with controller

So, let’s create a controller. we use Artisan command for generate controller template

php artisan make:controller PostController

now file PostController appear in /HTTP/Controllers

in this file

Modify this file as shown , creating a new public method called index. We’ll just return some text there.

Example 3–20. Simple controller example

<?php
use App\Http\Controllers\Controller;
class PostController extends Controller {    
     public function index() {
      return 'Hello, World!';   
     }
 }

next create route

// routes/web.php 
Route::get('/post', 'PostController@index');

That’s it. Visit the / route and you’ll see the words “Hello, World!”

Controller namespacing

if we need to group relate controller and keep in some folder . we need to know use namespace concept name space is concept for prevent class name conflict when we have two class with same name and keep in different folder

we need to update namespace with add admin after controller and include Controller class again

and update route add admin

try refresh

Getting input with post route

The second most common action to perform in a controller method is to take input from the user and act on it. we have route post for responsible this action

// routes/web.php 
Route::post('post', 'PostController@store');

now we bridge post url to store method

// PostController.php
 public function store(Request $request) {
      $task = new App\Post; 
      $task->title = $request->get('title'); 
      $task->body = $request->get('body'); 
      $task->save();
      return redirect('post.index'); 
}

This example makes use of Post models and the redirect() helper, and we’ll talk about them more later, but you can see what we’re doing here: we create a new Post,

Resource controller

Many time naming the methods in your controllers can be the hardest part of writing a controller. but, Laravel has some conventions for all of the routes of a traditional REST controller called a “resource controller” additionally, it comes with a generator out of the box and a convenience route definition that allows you to bind an entire resource controller at once.

To see the methods that Laravel expects for a resource controller, let’s generate a new controller from the command line:

php artisan make:controller PostController --resource

Now open app/Http/Controllers/PostController.php. You’ll see it comes .

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;

class PostController extends Controller
{
    /**
     * Display a listing of the resource.
     *
     * @return \Illuminate\Http\Response
     */
    public function index()
    {
        //
    }

    /**
     * Show the form for creating a new resource.
     *
     * @return \Illuminate\Http\Response
     */
    public function create()
    {
        //
    }

    /**
     * Store a newly created resource in storage.
     *
     * @param \Illuminate\Http\Request $request
     * @return \Illuminate\Http\Response
     */
    public function store(Request $request)
    {
        //
    }

    /**
     * Display the specified resource.
     *
     * @param int $id
     * @return \Illuminate\Http\Response
     */
    public function show($id)
    {
        //
    }

    /**
     * Show the form for editing the specified resource.
     *
     * @param int $id
     * @return \Illuminate\Http\Response
     */
    public function edit($id)
    {
        //
    }

    /**
     * Update the specified resource in storage.
     *
     * @param \Illuminate\Http\Request $request
     * @param int $id
     * @return \Illuminate\Http\Response
     */
    public function update(Request $request, $id)
    {
        //
    }

    /**
     * Remove the specified resource from storage.
     *
     * @param int $id
     * @return \Illuminate\Http\Response
     */
    public function destroy($id)
    {
        //
    }
}

now we can bind all method in post controller to one route

Route::resource('post','PostController');

If you ever find yourself in a situation where you’re wondering what resource routes has available, run php artisan route:list and you’ll get a listing of all of the available routes

now we have multiple route for handle multiple situation

Route Model Binding

One of the most common routing patterns is that the first line of any controller method tries to find the resource with the given ID, like in example

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

Laravel provides a feature that simplifies this pattern called “route model binding.” This allows you to define that a particular parameter name (e.g., {id}) will indicate to the route resolver that it should look up an Eloquent record with that ID and then pass it in as the parameter instead of just passing the ID. There are two type of model binding: implicit and custom .

Implicit Route Model Binding

The simplest way to use route model binding is to name your route parameter something unique to that model (e.g., name it $user instead of $id), then typehint that parameter in the closure or controller method and use the same variable name there. It’s easier to show than to describe, so take a look at example

Route::get('users/{user}', function (User $user) {
 return view('user.show')->with('user', $user);
 });

Every time this route is visited, the application will assume that whatever is passed into {user} is an ID that should be used to look up a User, and then that resulting model instance will be passed in to your second function

Custom Route Model Binding

To manually configure route model bindings, copy example below to the boot() method in App\Providers\RouteServiceProvider.

public function boot(Router $router) { 
// run parent's boot() method  
parent::boot($router);
// init the binding 
$router->model('user', User::class); 
}

You’ve now defined that whenever a route has a parameter in its definition named {user}, as in before, the route resolver will return an instance of the User class with the ID of that URL parameter.

Conclusion

Laravel’s routes is provide way to handle every moment in application access like a gate for our application it’s provide a lot out of the box feature like model binding ,resource route

in this post cover all this basic topic for route hope you enjoy much more than document

Originally published at Krissanawat Blog.


Discussion (0)

pic
Editor guide