• function

{{>key}} can.Mustache.helpers.partial

 

{{>key}}

Render another template within the current template.

Parameters

  1. key {key}

    A key that references a value within the current or parent context. If the value is a function or can.compute, the function's return value is used.

    If the key value is:

    • undefined - the key's name (ex: user.mustache in {{>user.mustaceh}}) is used to look up a template using can.view.

    • string - the string value is used to lookup a view in can.view.

    • function - the function is called with the current scope.

    can.view looks for a template in the following places:

    1. A registered view
    2. An id of an element
    3. A url to load the template.

Returns

{String}

The value of the rendered template is inserted into the page.

Partials are templates embedded in other templates. Partials begin with a greater than sign, like {{>my_partial}}. Partials inherit the calling context.

Partials render at runtime, so recursive partials are possible but make sure you avoid infinite loops.

For example, this template and partial:

base.mustache

<h2>Names</h2>
{{#names}}
    {{>user.mustache}}
{{/names}}

user.mustache

<strong>{{name}}</strong>

The resulting expanded template at render time would look like:

<h2>Names</h2>
{{#names}}
    <strong>{{name}}</strong>
{{/names}}

Acquiring Partials

Referencing Files

Partials can reference a file path and file name in the template.

The following template uses a relative path (relative to the current page):

<script id="template" type="text/mustache">
    {{>views/test_template.mustache}}
</script>

The following template uses an absolute path (rooted to steal's root directory):

<script id="template" type="text/mustache">
    {{>//myapp/accordion/views/test_template.mustache}}
</script>

Referencing by ID

Partials can reference templates that exist in script tags on the page by referencing the id of the partial in the template. For example:

<script id="mytemplate" type="text/mustache">
    {{>mypartial}}
</script>
<script id="mypartial" type="text/mustache">
       I am a partial.
</script>
var template = can.view("#mytemplate", {});

Manually Registering

Partials can be manually registered by calling can.view.registerView and passing an identifier and content. For example:

can.view.registerView('myTemplate', "My body lies over {{.}}")

in the template, you reference the template by the identifer you registered:

{{>myTemplate}}

resulting in the template rendering with the current context applied to the partial.

Passing Partials in Options

Partials can resolve the context object that contain partial identifiers in them. For example:

var template = can.view("#template", { 
    items: []
    itemsTemplate: "test_template.mustache" 
});

can.$(document.body).append(template);

then reference the partial in the template just like:

<ul>
{{#items}}
    <li>{{>itemsTemplate}}</li>
{{/items}}
</ul>