Mustache

Zero-dependency, logic-less template engine for JavaScript. Renders tags in templates using values from a view object.

Triggers

when the user asks to render templates, use Mustache syntax {{ }}, create .mustache files,generate HTML/config/code from templates, or mentions mustache/mustache.js/{{mustache}}.

Covers

variables, sections, inverted sections, partials, comments, custom delimiters, CLI usage,

pre-parsing/caching, and common patterns (email templates, config generation, code scaffolding).

Install

npm install mustache --save        # project dependency
npm install -g mustache            # CLI tool

Core API

const Mustache = require('mustache');
const html = Mustache.render(template, view, partials, tags);

• template (string) — Mustache template string
• view (object) — data & helper functions
• partials (object, optional) — { name: partialString }
• tags (string[], optional) — custom delimiters [ open, close ]

Tag Types Quick Reference

| Tag | Syntax | Behavior |

|-----|--------|----------|

| Variable | {{key}} | HTML-escaped value |

| Unescaped | {{{key}}} or {{&key}} | Raw HTML output |

| Dot notation | {{a.b.c}} | Nested property access |

| Current item | {{.}} | Current item in string array loop |

| Section | {{#key}}...{{/key}} | Truthy → render block; array → loop |

| Inverted | {{^key}}...{{/key}} | Falsy/empty → render block |

| Comment | {{! text }} | Stripped from output |

| Partial | {{> name}} | Inline another template |

| Set Delimiter | {{=<% %>=}} | Change tag delimiters |

Sections — Detailed

Falsy (skip): null, undefined, false, 0, NaN, "", [] → block not rendered.

Non-empty array (loop): Block renders once per item; context shifts to each item.

// String array — use {{.}} for current item
Mustache.render('{{#items}}- {{.}}\n{{/items}}', { items: ['a','b'] });
// → "- a\n- b\n"

// Object array — access properties directly
Mustache.render('{{#people}}* {{name}}\n{{/people}}', {
  people: [{ name: 'Alice' }, { name: 'Bob' }]
});
// → "* Alice\n* Bob\n"

// Lambda function — receives raw block text + render helper
Mustache.render('{{#bold}}Hi {{name}}{{/bold}}', {
  name: 'World',
  bold: function() {
    return function(text, render) {
      return '<b>' + render(text) + '</b>';
    };
  }
});
// → "<b>Hi World</b>"

Partials

Pass as third argument; inherit the calling context.

Mustache.render(
  '<h2>Names</h2>{{#names}}{{> user}}{{/names}}',
  { names: [{ name: 'Alice' }, { name: 'Bob' }] },
  { user: '<strong>{{name}}</strong>\n' }
);
// → <h2>Names</h2>\n<strong>Alice</strong>\n<strong>Bob</strong>\n

Custom Delimiters

// JS: pass as 4th argument or set Mustache.tags
Mustache.render(template, view, {}, ['<%', '%>']);

// Template: set delimiter inline
{{=<% %>=}}<% erb_style %><%={{ }}=%>
// Delimiters may not contain whitespace or =

Pre-parsing / Caching

Mustache.parse(template);  // cache parsed tree
// Later calls with the same template skip parsing

CLI Usage

mustache data.json template.mustache > output.html
mustache data.json -p partials/header.mustache -p partials/footer.mustache template.mustache
cat data.json | mustache - template.mustache > output.html

Common Patterns

For detailed examples and anti-patterns, see references/patterns.md.

Escape override (for non-HTML like config files):

Mustache.escape = t => t;

Include template in HTML (static sites):

<script id="tpl" type="x-tmpl-mustache">{{> content}}</script>

Async load template (SPAs):

fetch('tpl.mustache').then(r => r.text()).then(t => {
  document.getElementById('out').innerHTML = Mustache.render(t, data);
});

Anti-patterns

• Do NOT put logic in views — Mustache is logic-less; move logic to pre-processing
• Avoid recursive partials without a termination condition
• Do NOT use Mustache.escape = t => t globally without restoring it afterward