This title was written for Laravel version 4. If you're looking for material on the latest version of Laravel, then please check out Code Smart.
Your web application revolves around routes and URLs. After all, they are what direct your users to your pages. At the end of the day, serving pages is what any web application must do.
Your users might not be interested for long if you are only serving one page, and if you intend to move them around your website or web application, then you will need to use a critical feature of the web. What feature, you ask? Well, hyper-links!
In order to construct hyper links we need to build URLs to our application. We could do them by hand, but Laravel can save us some effort by providing a number of helpers to assist with the construction of URLs. Let’s take a look at those features.
The current URL
Getting the current URL in Laravel is easy. Simply use the URL::current()
helper. Let’s create a simple route to test it.
<?php
// app/routes.php
Route::get('/current/url', function()
{
return URL::current();
});
Now if we visit our /current/url
url, we receive the following response.
http://myapp.dev/current/url
Well that was simple wasn’t it? Let’s have a look at URL::full()
next, you see it returns the current URL.
Erm. Didn’t we just do that?
Well, it’s a little bit different. Let’s try that last route once more, but this time we will include some additional data as GET parameters.
http://myapp.dev/current/url?foo=bar
You will see that the result of URL::current()
strips off the extra request data, like this:
http://myapp.dev/current/url
Well the URL::full()
method is a little different. Let’s modify our existing route to use it. Like this:
<?php
// app/routes.php
Route::get('/current/url', function()
{
return URL::full();
});
Now let’s try the /current/url?foo=bar
URL again. This time we get the following result:
http://myapp.dev/current/url?foo=bar
You see, the URL::full()
method also includes additional request data.
This next one isn’t really a way of getting the current URL, but I feel that it certainly has its place in this sub heading. You see, it’s a method of getting the previous URL, as denoted by the ‘referer’ request header.
I have come up with a cunning trap using a Redirect response type to display the output. Take a look at the following example.
<?php
// app/routes.php
Route::get('first', function()
{
// Redirect to the second route.
return Redirect::to('second');
});
Route::get('second', function()
{
return URL::previous();
});
So our first route, redirects to the second route. The second route will output the URL of the previous request using the URL::previous()
method.
Let’s visit the /first
URI to see what happens.
You might have seen the redirect notice displayed for a split second, but hopefully you will have received the following response:
http://demo.dev/first
You see, after the redirect, the URL::previous
method gives the URL for the previous request, which in this instance is the URL to the first route. It’s as simple as that!
Generating Framework URLs
This section is all about generating URLs that will help us navigate around the different routes or pages of our site or application.
Let’s start by generating URLs to specific URI’s. We can do this using the URL::to()
method. Like this:
<?php
// app/routes.php
Route::get('example', function()
{
return URL::to('another/route');
});
The response we receive when we visit /example
looks like this.
http://demo.dev/another/route
As you can see, Laravel has built a URL to the route we requested. You should note that the another/route
doesn’t exist, but we can link to it anyway. Make sure that you remember this when generating links to URIs.
You can specify additional parameters to the URL::to()
method in the form of an array. These parameters will be appended to the end of the route. Here’s an example:
<?php
// app/routes.php
Route::get('example', function()
{
return URL::to('another/route', array('foo', 'bar'));
});
The resulting string will take the following form.
http://myapp.dev/another/route/foo/bar
If you want your generated URLs to use the HTTPS protocol, then you have two options. The first option is to pass true
as the third parameter to the URL::to()
method, like this:
URL::to('another/route', array('foo', 'bar'), true);
However, if you don’t want to provide parameters to your URL, you will have to pass an empty array, or null as the second parameter. Instead, it’s more effective to use the descriptive URL::secure()
method, like this:
URL::secure('another/route');
Once again, you can pass an array of route parameters as the second method parameter to the URL::secure()
method, like this:
URL::secure('another/route', array('foo', 'bar'));
Let’s look at the next generation method. Do you remember that we discovered how to give our routes nicknames within the advanced routing chapter? Named routes look like this:
<?php
// app/routes.php
Route::get('the/best/avenger', array('as' => 'ironman', function()
{
return 'Tony Stark';
}));
Route::get('example', function()
{
return URL::route('ironman');
});
If we visit the /example
route, we receive the following response.
http://myapp.dev/the/best/avenger
Laravel has taken our route nickname, and found the associated URI. If we were to change the URI, the output would also change. This is very useful for avoiding having to change a single URI for many views.
Just like the URL::to()
method, the URL::route()
method can accept an array of parameters as the second method parameter. Not only that, but it will insert them in the correct order within the URI. Let’s take a look at this in action.
<?php
// app/routes.php
Route::get('the/{first}/avenger/{second}', array(
'as' => 'ironman',
function($first, $second) {
return "Tony Stark, the {$first} avenger {$second}.";
}
));
Route::get('example', function()
{
return URL::route('ironman', array('best', 'ever'));
});
If we visit the following URL...
http://myapp.dev/example
...Laravel will fill in the blanks in the correct order, with the parameters we have provided. The following URL is displayed a response.
http://myapp.dev/the/best/avenger/ever
There’s one final routing method of this type that you need to know, and that’s how to route to controller actions. In fact, this one should be pretty simple, since it follows the same pattern as the URL::route()
method. Let’s take a look at an example.
<?php
// app/routes.php
// Our Controller.
class Stark extends BaseController
{
public function tony()
{
return 'You can count on me, to pleasure myself.';
}
}
// Route to the Stark controller.
Route::get('i/am/iron/man', 'Stark@tony');
Route::get('example', function()
{
return URL::action('Stark@tony');
});
In this example, we create a new controller called ‘Stark’ with a ‘tony()’ action. We create a new route for the controller action. Next we create an example route which returns the value of the URL::action()
method. The first parameter of this method is the Class and action combination that we wish to retrieve the URL for. The format for this parameter is identical to that which we use for routing to controllers.
If we visit the /example
URL, we receive the following response.
http://myapp.dev/i/am/iron/man
Laravel has identified the URL for the controller action pair that we requested, and delivered it as a response. Just as with the other methods, we can supply an array of parameters as a second parameter to the URL::action()
method. Let’s see this in action.
<?php
// app/routes.php
// Our Controller.
class Stark extends BaseController
{
public function tony($whatIsTony)
{
// ...
}
}
// Route to the Stark controller.
Route::get('tony/the/{first}/genius', 'Stark@tony');
Route::get('example', function()
{
return URL::action('Stark@tony', array('narcissist'));
});
Just as in the last example, we supply an array with a single parameter as a parameter to the URL::action()
method, and Laravel constructs the URL to the controller, with the parameter in the correct location.
The URL that we receive looks like this.
http://myapp.dev/tony/the/narcissist/genius
Well that’s it for route URL generation. I’m sorry if that got a bit repetitive, but hopefully it will make for a good reference chapter.
Asset URLs
URLs to assets such as images, CSS files and JavaScript need to be handled a little differently. Most of you will be using pretty URLs with Laravel. This is the act of rewriting the URL to remove the index.php
front controller, and making our URLs more SEO friendly.
However, in some sithations you may not wish to use pretty URLs. However, if you were to try to link to an asset using the helpers mentioned in the previous subchapter, then the index.php
portion of the URL would be included, and the asset links would break.
Even with pretty URLs, we don’t want to link to our assets using relative URLs because our routing segments will be confused for a folder structure.
As always, Laravel, and Taylor, are one step ahead of us. Helpers are provided to generate absolute URLs to our assets. Let’s take a look at some of these helpers.
First we have the URL::asset()
method, let’s take a look at it in action. The first parameter to the method is the relative path to the asset.
<?php
// app/routes.php
Route::get('example', function()
{
return URL::asset('img/logo.png');
});
Now, if we visit the URL /example
then we are greeted with the following response.
http://myapp.dev/img/logo.png
Laravel has created an absolute asset path for us. If we want to use a secure HTTPS protocol to reference our assets, then we can pass true
as a second parameter to the URL::asset()
method, like this:
<?php
// app/routes.php
Route::get('example', function()
{
return URL::asset('img/logo.png', true);
});
Now we receive the following response from the /example
URL.
https://demo.dev/img/logo.png
Great! Laravel also provides a much more descriptive method of generating secure asset URLs. Simply use the URL::secureAsset()
method and pass the relative path to your asset.
<?php
// app/routes.php
Route::get('example', function()
{
return URL::secureAsset('img/logo.png');
});
The response from this route is the same as the previous method.
https://demo.dev/img/logo.png
Generation Shortcuts
The methods mentioned in the previous subheadings are freely available for you to use in your views. Go ahead and take advantage of all of the features that they have to offer.
However, it’s good practice for the logic in your views to be short and neat. Also, it takes some stress off your fingers. This is why Laravel has provided some shortcuts to some of the methods available on the URL
class. Let’s take a closer look at what’s available.
First we have the url()
function. It accepts identical parameters to the URL::to()
method, so I won’t cover them again. Here’s an example of it in action.
<!-- app/views/example.blade.php -->
<a href="{{ url('my/route', array('foo', 'bar'), true) }}">My Route</a>
Now if we look at the link within the rendered view’s source, we see the following.
<a href="https://demo.dev/my/route/foo/bar">My Route</a>
The URL has been created in the same manner as the URL::to()
method. As before, there is also a shortcut method that can be used to generate a secure URL. It looks like this:
<!-- app/views/example.blade.php -->
<a href="{{ secure_url('my/route', array('foo', 'bar')) }}">My Route</a>
The secure_url()
function accepts the same signature as the URL::secure()
method. The first parameter is the route, and the second is an array of route parameters to be appended.
The route()
function is a shortcut to the URL::route()
method, and be used for generating URLs to named routes. It looks like this:
<!-- app/views/example.blade.php -->
<a href="{{ route('myroute') }}">My Route</a>
As you might have guessed, there is also a shortcut for the third method of route URL generation. The action()
function can be used as a shortcut to the URL::action()
method, and can be used to generate links to controller actions.
<!-- app/views/example.blade.php -->
<a href="{{ action('MyController@myAction') }}">My Link</a>
Just as with the URL::action()
method, they can accept second and third parameters for route parameters and secure URL generation.
<!-- app/views/example.blade.php -->
<a href="{{ action('MyController@myAction', array('foo'), true) }}">My Link</a>
The shortcut to the URL::asset()
method is the asset()
function, and as with all the other shortcuts, it accepts identical function parameters. Here’s an example:
<!-- app/views/example.blade.php -->
<img src="{{ asset('img/logo.png') }}" />
Likewise, the shortcut to URL::secureAsset()
is the secure_asset()
function. It looks like this:
<!-- app/views/example.blade.php -->
<img src="{{ secure_asset('img/logo.png') }}" />
Feel free to use the shortcuts in your views to simplify their content, and to avoid repetitive strain injury.
My books are available online for free to encourage learning. However, if you'd like for me to keep writing, then please consider buying a digital copy over at Leanpub.com.
It's available in PDF, ePub, and Kindle format, and contains a bunch of extras that you won't find on the site. I have a full-time job, and I write my books in my spare time. Please consider buying a copy so that I can continue to write new books from the comfort of my sofa!