DoneJS StealJS jQuery++ FuncUnit DocumentJS
3.14.1
5.0.0 4.3.0 2.3.35
  • About
  • Guides
  • API Docs
  • Community
  • Contributing
  • Bitovi
    • Bitovi.com
    • Blog
    • Design
    • Development
    • Training
    • Open Source
    • About
    • Contact Us
  • About
  • Guides
  • API Docs
    • Observables
      • can-compute
      • can-define
      • can-define/list/list
      • can-define/map/map
      • can-define-stream
      • can-define-stream-kefir
      • can-event
      • can-event/async/async
      • can-event/batch/batch
      • can-event/lifecycle/lifecycle
      • can-kefir
      • can-list
      • can-map
      • can-map-backup
      • can-map-define
      • can-observation
      • can-observe
      • can-simple-map
      • can-simple-observable
      • can-stream
      • can-stream-kefir
    • Data Modeling
      • can-connect
      • can-connect-cloneable
      • can-connect-feathers
      • can-connect-ndjson
      • can-connect-signalr
      • can-fixture
      • can-fixture-socket
      • can-ndjson-stream
      • can-set
    • Views
      • can-component
      • can-ejs
      • can-element
      • can-react-component
      • can-stache
        • Pages
          • Magic Tag Types
          • Scope and Context
          • Expressions
          • Template Acquisition
          • Helpers
          • Live Binding
          • Whitespace Control
          • Sections
        • Methods
          • addHelper
          • addLiveHelper
          • from
          • registerConverter
          • registerHelper
          • registerPartial
          • registerSimpleHelper
          • safeString
        • Tags
          • {{expression}}
          • {{{expression}}}
          • {{#expression}}
          • {{/expression}}
          • {{^expression}}
          • {{>key}}
          • {{!expression}}
          • {{<partialName}}
          • {{else}}
        • Expressions
          • Bracket Expression
          • Call Expression
          • Hash Expression
          • Helper Expression
          • KeyLookup Expression
          • Literal Expression
        • Key Operators
          • @at
          • ~compute
          • ./current
          • ../parent
          • scope
          • %special
          • this
          • *variable
          • *self
          • key
        • Helpers
          • {{#if(expression)}}
          • {{#unless(expression)}}
          • {{#each(expression)}}
          • {{#with(expression)}}
          • {{log()}}
          • {{debugger()}}
          • {{#eq(expressions)}}
          • {{#is(expressions)}}
          • {{#switch(expression)}}
          • {{#case(expression)}}
          • {{#default()}}
          • {{joinBase(expressions)}}
        • Types
          • getterSetter
          • helper
          • helperOptions
          • renderer
          • sectionRenderer
          • simpleHelper
      • can-stache/helpers/route
      • can-stache-bindings
      • can-stache-converters
      • can-view-autorender
      • can-view-callbacks
      • can-view-href
      • can-view-import
      • can-view-live
      • can-view-model
      • can-view-nodelist
      • can-view-parser
      • can-view-scope
      • can-view-target
      • react-view-model
      • react-view-model/component
      • steal-stache
    • Routing
      • can-deparam
      • can-param
      • can-route
      • can-route-pushstate
    • JS Utilities
      • can-assign
      • can-define-lazy-value
      • can-globals
      • can-key-tree
      • can-make-map
      • can-parse-uri
      • can-string
      • can-string-to-any
      • can-util
      • can-zone
      • can-zone-storage
    • DOM Utilities
      • can-ajax
      • can-attribute-encoder
      • can-control
      • can-dom-events
      • can-event-dom-enter
      • can-event-dom-radiochange
      • can-jquery
    • Data Validation
      • can-define-validate-validatejs
      • can-validate
      • can-validate-interface
      • can-validate-legacy
      • can-validate-validatejs
    • Typed Data
      • can-cid
      • can-construct
      • can-construct-super
      • can-namespace
      • can-reflect
      • can-reflect-promise
      • can-types
    • Polyfills
      • can-symbol
      • can-vdom
    • Core
    • Infrastructure
      • can-global
      • can-test-helpers
    • Ecosystem
    • Legacy
  • Community
  • Contributing
  • GitHub
  • Twitter
  • Chat
  • Forum
  • News
Bitovi

{{>key}}

  • Edit on GitHub

Render another template within the current template.

{{>key [EXPRESSION]}}

Looks up another template with key and renders it with the current scope or EXPRESSION added on top of the current scope.

stache.registerPartial("address.stache", "<p>{{street}} {{city}}</p>");
var template = stache("{{#each(people)}} {{>address.stache address}} {{/each}}");

Parameters

  1. key {KeyLookup Expression|String}:

    A key used to lookup a stache renderer function.

    The behavior is determined by what the key returns.

    If the key returns a function, that function is used as the renderer function. The renderer function is called with the current scope (or a scope modified by EXPRESSION) and the result is inserted in place of the magic tag.

    If the key returns a string, that string is used as the renderer function name. If the key returns undefined, the key itself is used as the renderer function name.

    Once the renderer function name is known, the renderer function is looked for by the same name. A renderer function is looked for in the following places:

    1. In Options’s partials property.
    2. In partials registered with registerPartial.
    3. For an element whose id matches renderer function name. Its innerHTML will be converted to a template.

    The renderer function is called with the current scope (or a scope modified by EXPRESSION) and the result is inserted in place of the magic tag.

  2. EXPRESSION {KeyLookup Expression|Call Expression}:

    An optional expression that adds a new context to the can-view-scope the template is rendered with.

Use

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

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

Partials are typically registered registerPartial like:

stache.registerPartial("address.stache", "<p>{{street}} {{city}}</p>");

And called within another template like:

var template = stache("{{#person.address}} {{>address.stache}} {{/person.address}}");

With data like {person: {address: {street: "123 Evergreen", city: "Chicago"}}}, rendering template would produce:

<p>123 Evergreen Chicago</p>

The 2nd argument to {{>key}} can specify a different context for the partial to be rendered with. The following example renders the same thing as above:

var template = stache("{{#person}} {{>address.stache address}} {{/person}}");

Functions as partials

{{>key}} can be used to call renderer functions in the scope. For example:

<!-- Template -->
{{#item}}{{>myPartial}}{{/item}}
/* Data */
{
  item: {name: "Justin"},
  myPartial: stache("{{name}}")
}
<!-- Result -->
Justin

Script tags as partials

{{>key}} can be used to render the contents of script tags.

For example, if you've embedded a partial like:

<script type='text/stache' id='todo-stache'>
  <li>{{name}}</li>
</script>

This can be rendered like:

{{#each(todos)}}{{>todo-stache}}{{/each}}

CanJS is part of DoneJS. Created and maintained by the core DoneJS team and Bitovi. Currently 3.14.1.

On this page

Get help

  • Chat with us
  • File an issue
  • Ask questions
  • Read latest news