This is the home page.
@foreach($news as $item){{{ $item->summary }}}
{{{ $comment->body }}}
@emptyNo comments yet.
@endforelse ``` `@forelse` renders the `@empty` block when the list is empty. I reach for this combination constantly; previously I'd write a separate `count($array) > 0` check. ## Partials Moving repeated pieces into separate files keeps things tidy. I put the navigation into `app/views/partials/menu.blade.php`: ```html ``` Every page just writes `@include('partials.menu')` and Blade handles the rest. ## Passing data from the controller to the view There are a few ways to pass variables from a controller to a view: ```php // Using compact() $news = News::all(); return View::make('home', compact('news')); // Method chaining with with() return View::make('home')->with('news', News::all()); ``` Both produce the same result; `compact()` is more convenient when you're passing multiple variables at once. ## Running raw PHP expressions Occasionally you need PHP that doesn't have a Blade directive. You can open a plain PHP tag inside the template: ```htmlTotal: {{ $total }}
``` I use this sparingly — business logic should not creep into the view layer. But for simple calculations it gets the job done. ## The escape hatch: rendering raw HTML Blade's `{{{ }}}` syntax escapes HTML — and that's a good thing. But if you're storing HTML content in the database and need to render it as-is, you use the `{{ }}` syntax: ```html {{ $article->content }} ``` This should only be used for content you fully trust. Rendering user-submitted input with `{{ }}` completely disables XSS protection. I learned this distinction on a CMS project: `{{ }}` was the right call for HTML articles coming from an editor, but using the same syntax for comment fields would have opened a security hole. ## Compared to the old approach With the old `header.php` / `footer.php` pattern, every page needed two includes and I had to keep their interdependencies in my head. Blade's inheritance model inverts this: there's a central layout file, and child pages attach to it. Adding a new page is far cleaner. After a few weeks of use, I appreciate the structure a template engine brings. The `@forelse` and `@include` combination alone has noticeably reduced repetitive code. And having escaping boiled down to a short `{{{ }}}` syntax means security is no longer a `htmlspecialchars()` call you have to "remember" each time. Blade has one more feature worth mentioning: the `@stack` and `@push` directives let you inject page-specific CSS or JavaScript blocks into a designated slot in the layout. For example, if a page requires a specific JavaScript library, you can push it from that page's view into a `@stack('scripts')` slot defined just before the layout's `