Blade Views

Blade sets a $loop object on every @foreach iteration with index (from 0), iteration (from 1), count, remaining, first, last, odd, even, depth and parent, so rows can be styled without a hand-kept counter.

Blade compiles {{ $value }} to an echo through the e() helper, which runs htmlspecialchars so markup prints as text; {!! $value !!} echoes the value untouched, so it is safe only for HTML your own code built or sanitized.

A layout component wraps the page: markup between <x-layout> tags lands in the component's {{ $slot }}. An @extends layout is inheritance: the child fills @section blocks that the layout prints with @yield. New apps usually choose components.

merge() adds default attributes: class and style defaults are joined with the caller's values, while any other default is replaced by the caller's value. class() adds classes conditionally; prepends() makes a non-class default join instead.

A page or component adds markup to a named stack with @push('scripts'), and the layout prints everything collected with @stack('scripts'). @prepend puts content ahead of pushed content, and @pushOnce adds a block only once per render.

@forelse loops like @foreach but renders its @empty branch when the list has no items. A standalone @empty($x) ... @endempty is a different directive that wraps PHP's empty(), which is false for any object, even an empty Collection.

Prefixing an echo with @, as in @{{ name }}, makes Blade drop the @ and leave {{ name }} for the JavaScript framework. Wrapping a region in @verbatim ... @endverbatim leaves everything inside uncompiled, echoes and directives alike.

Blade compiles each template into a plain PHP file stored in storage/framework/views (config key view.compiled, env VIEW_COMPILED_PATH). On render Laravel reuses it unless it is missing or the source file's modification time is not older than the compiled file's.

Content between a component's tags that is not inside an x-slot becomes $slot; each x-slot:name becomes a $name variable. Slots are ComponentSlot objects with isEmpty(), hasActualContent() and their own attributes bag, and an optional slot needs a default.

A plain attribute passes a string, a colon attribute passes a PHP expression's value, and a double colon emits a single-colon attribute for JavaScript. Names in @props or the constructor become variables; the rest stay in $attributes.

@class and @style take an array of always-on entries plus entry => condition pairs and write a complete class or style attribute; @checked, @selected, @disabled, @readonly and @required print the bare attribute when their condition is true.

@include and its If, When, Unless and First variants hand the partial every parent variable plus extras, differing only in when they render; @includeIsolated passes just the given array, and @each renders a view per item with only that item and its key.

Use Js::from($data) or the @js directive: they emit a JavaScript expression with <, >, &, and quotes hex-escaped. {{ json_encode() }} fails because e() turns quotes into ", which a script block never decodes.

The child renders first, so its section is stored first and wins. A layout default written as @section ... @show only survives where the child wrote @parent, which is a placeholder for it. @endsection only stores; @show and @yield print.

Blade::if('plan', fn (string $plan) => ...) registers @plan, @elseplan, @unlessplan and @endplan that call your closure through Blade::check() each render; a Blade::directive handler runs once at compile time, so per-visitor logic inside it gets frozen into the cached view.

e() only stops a value breaking out of quoted HTML. Unquoted attributes break on a space, a javascript: URL has nothing to encode, and an onclick attribute is entity-decoded before its JavaScript runs, so each needs quoting, a scheme check or Js::from.

Blade's e() helper returns any Htmlable object's toHtml() without escaping, and HtmlString is Htmlable, so a bio wrapped in one renders as live markup inside {{ }}; the wrapper must only ever hold HTML your code has sanitized.

View::share sets a value once, in a provider's boot(), for every view. A view composer runs just before a named view renders, so it suits data that only some pages need. A creator runs when the view is created, before render.

Blade's e() double-encodes by default, so an entity already in the data becomes &amp; and shows as &. Blade::withoutDoubleEncoding() compiles {{ }} to e($x, false), leaving existing entities intact while still escaping < and >.

Wrap the list in @fragment('course-list') ... @endfragment. Returning view(...)->fragment('course-list') renders the template but sends only that block, and fragmentIf($condition, 'course-list') does so only when the condition holds, otherwise the full page.

@aware(['size' => 'md']) lets a child read size from the data of its enclosing components. For an anonymous parent that data is only what the caller wrote on the tag, not @props defaults, so the child needs a matching default.