Views

Creating Views

Views contain the HTML served by your application and separate your controller / application logic from your presentation logic. Views are stored in the resources/views directory. A simple view might look something like this:

  1. <!-- View stored in resources/views/greeting.blade.php -->
  3. <html>
  4.     <body>
  5.         <h1>Hello, {{ $name }}</h1>
  6.     </body>
  7. </html>

Since this view is stored at resources/views/greeting.blade.php, we may return it using the global view helper like so:

  1. Route::get('/', function () {
  2.     return view('greeting', ['name' => 'James']);
  3. });

As you can see, the first argument passed to the view helper corresponds to the name of the view file in the resources/views directory. The second argument is an array of data that should be made available to the view. In this case, we are passing the name variable, which is displayed in the view using Blade syntax.

Of course, views may also be nested within sub-directories of the resources/views directory. "Dot" notation may be used to reference nested views. For example, if your view is stored at resources/views/admin/profile.blade.php, you may reference it like so:

  1. return view('admin.profile', $data);

Determining If A View Exists

If you need to determine if a view exists, you may use the View facade. The exists method will return true if the view exists:

  1. use Illuminate\Support\Facades\View;
  3. if (View::exists('emails.customer')) {
  4.     //
  5. }

Passing Data To Views

As you saw in the previous examples, you may pass an array of data to views:

  1. return view('greetings', ['name' => 'Victoria']);

When passing information in this manner, $data should be an array with key/value pairs. Inside your view, you can then access each value using its corresponding key, such as <?php echo $key; ?>. As an alternative to passing a complete array of data to the view helper function, you may use the with method to add individual pieces of data to the view:

  1. return view('greeting')->with('name', 'Victoria');

Sharing Data With All Views

Occasionally, you may need to share a piece of data with all views that are rendered by your application. You may do so using the view facade's share method. Typically, you should place calls to share within a service provider's boot method. You are free to add them to the AppServiceProvider or generate a separate service provider to house them:

  1. <?php
  3. namespace App\Providers;
  5. use Illuminate\Support\Facades\View;
  7. class AppServiceProvider extends ServiceProvider
  8. {
  9.     /**
  10.      * Bootstrap any application services.
  11.      *
  12.      * @return void
  13.      */
  14.     public function boot()
  15.     {
  16.         View::share('key', 'value');
  17.     }
  19.     /**
  20.      * Register the service provider.
  21.      *
  22.      * @return void
  23.      */
  24.     public function register()
  25.     {
  26.         //
  27.     }
  28. }

View Composers

View composers are callbacks or class methods that are called when a view is rendered. If you have data that you want to be bound to a view each time that view is rendered, a view composer can help you organize that logic into a single location.

For this example, let's register the view composers within a service provider. We'll use the View facade to access the underlying Illuminate\Contracts\View\Factory contract implementation. Remember, Laravel does not include a default directory for view composers. You are free to organize them however you wish. For example, you could create an App\Http\ViewComposers directory:

  1. <?php
  3. namespace App\Providers;
  5. use Illuminate\Support\Facades\View;
  6. use Illuminate\Support\ServiceProvider;
  8. class ComposerServiceProvider extends ServiceProvider
  9. {
  10.     /**
  11.      * Register bindings in the container.
  12.      *
  13.      * @return void
  14.      */
  15.     public function boot()
  16.     {
  17.         // Using class based composers...
  18.         View::composer(
  19.             'profile', 'App\Http\ViewComposers\ProfileComposer'
  20.         );
  22.         // Using Closure based composers...
  23.         View::composer('dashboard', function ($view) {
  24.             //
  25.         });
  26.     }
  28.     /**
  29.      * Register the service provider.
  30.      *
  31.      * @return void
  32.      */
  33.     public function register()
  34.     {
  35.         //
  36.     }
  37. }

{note} Remember, if you create a new service provider to contain your view composer registrations, you will need to add the service provider to the providers array in the config/app.php configuration file.

Now that we have registered the composer, the [email protected] method will be executed each time the profile view is being rendered. So, let's define the composer class:

  1. <?php
  3. namespace App\Http\ViewComposers;
  5. use Illuminate\View\View;
  6. use App\Repositories\UserRepository;
  8. class ProfileComposer
  9. {
  10.     /**
  11.      * The user repository implementation.
  12.      *
  13.      * @var UserRepository
  14.      */
  15.     protected $users;
  17.     /**
  18.      * Create a new profile composer.
  19.      *
  20.      * @param  UserRepository  $users
  21.      * @return void
  22.      */
  23.     public function __construct(UserRepository $users)
  24.     {
  25.         // Dependencies automatically resolved by service container...
  26.         $this->users = $users;
  27.     }
  29.     /**
  30.      * Bind data to the view.
  31.      *
  32.      * @param  View  $view
  33.      * @return void
  34.      */
  35.     public function compose(View $view)
  36.     {
  37.         $view->with('count', $this->users->count());
  38.     }
  39. }

Just before the view is rendered, the composer's compose method is called with the Illuminate\View\View instance. You may use the with method to bind data to the view.

{tip} All view composers are resolved via the service container, so you may type-hint any dependencies you need within a composer's constructor.

Attaching A Composer To Multiple Views

You may attach a view composer to multiple views at once by passing an array of views as the first argument to the composer method:

  1. View::composer(
  2.     ['profile', 'dashboard'],
  3.     'App\Http\ViewComposers\MyViewComposer'
  4. );

The composer method also accepts the * character as a wildcard, allowing you to attach a composer to all views:

  1. View::composer('*', function ($view) {
  2.     //
  3. });

View Creators

View creators are very similar to view composers; however, they are executed immediately after the view is instantiated instead of waiting until the view is about to render. To register a view creator, use the creator method:

  1. View::creator('profile', 'App\Http\ViewCreators\ProfileCreator');