evo play slot

馃弳evo play slot馃弳銆恟etirementfiduciary.com銆戔殹锔廲omo fazer jogo da loteria鈿★笍

This page assumes you've already read the Components Basics. Read that first if you are

new to components.

Slot Content and 馃導锔? Outlet 鈥?/p>

We have learned that components can accept

props, which can be JavaScript values of any type. But how about 馃導锔? template content? In

some cases, we may want to pass a template fragment to a child component, and let the

馃導锔? child component render the fragment within its own template.

For example, we may have a

component that supports usage like 馃導锔? this:

template < FancyButton > Click

me!

The template of looks like

this:

template < 馃導锔? button class = "fancy-btn" > < slot >

button >

The element is 馃導锔? a slot outlet that indicates where the parent-provided

slot content should be rendered.

And the final rendered DOM:

html < button class 馃導锔? =

"fancy-btn" >Click me!

With slots, the is responsible for

rendering the outer (and its fancy styling), 馃導锔? while the inner content is

provided by the parent component.

Another way to understand slots is by comparing them

to JavaScript 馃導锔? functions:

js // parent component passing slot content FancyButton (

'Click me!' ) // FancyButton renders slot content in its own 馃導锔? template function

FancyButton ( slotContent ) { return `

R${ slotContent }

` }

Slot content is not just limited to 馃導锔? text. It can be any valid template

content. For example, we can pass in multiple elements, or even other

components:

template 馃導锔? < FancyButton > < span style = "color:red" >Click me! <

AwesomeIcon name = "plus" />

By using slots, our is more

flexible and reusable. We can now use it in different places with different 馃導锔? inner

content, but all with the same fancy styling.

Vue components' slot mechanism is

inspired by the native Web Component 馃導锔? element, but with additional capabilities

that we will see later.

Render Scope 鈥?/p>

Slot content has access to the data scope of 馃導锔? the

parent component, because it is defined in the parent. For example:

template < span >{{

message }} < 馃導锔? FancyButton >{{ message }}

Here both {{ message

}} interpolations will render the same content.

Slot content does not have 馃導锔? access to

the child component's data. Expressions in Vue templates can only access the scope it

is defined in, consistent 馃導锔? with JavaScript's lexical scoping. In other

words:

Expressions in the parent template only have access to the parent scope;

expressions in 馃導锔? the child template only have access to the child scope.

Fallback Content

鈥?/p>

There are cases when it's useful to specify fallback 馃導锔? (i.e. default) content for a

slot, to be rendered only when no content is provided. For example, in a

馃導锔? component:

template < button type = "submit" > < slot >

We might

want the text "Submit" 馃導锔? to be rendered inside the if the parent didn't provide

any slot content. To make "Submit" the fallback content, 馃導锔? we can place it in between the

tags:

template < button type = "submit" > < slot > Submit

Now when we use in a parent component,

providing no content 馃導锔? for the slot:

template < SubmitButton />

This will render the

fallback content, "Submit":

html < button type = "submit" >Submit

But 馃導锔? if we

provide content:

template < SubmitButton >Save

Then the provided

content will be rendered instead:

html < button type = 馃導锔? "submit" >Save

Named

Slots 鈥?/p>

There are times when it's useful to have multiple slot outlets in a single

component. 馃導锔? For example, in a component with the following

template:

template < div class = "container" > < header > < main > < footer >

For these cases, 馃導锔? the

element has a special attribute, name , which can be used to assign a unique ID to

different 馃導锔? slots so you can determine where content should be rendered:

template < div

class = "container" > < header > < 馃導锔? slot name = "header" > < main >

< slot > < footer > < slot name = "footer" >

div >

A outlet 馃導锔? without name implicitly has the name "default".

In a parent

component using , we need a way to pass multiple 馃導锔? slot content fragments,

each targeting a different slot outlet. This is where named slots come in.

To pass a

named slot, 馃導锔? we need to use a