mustache alternatives and similar packages
Based on the "Template Engines" category.
Alternatively, view mustache alternatives based on common mentions on social networks and blogs.
-
quicktemplate
Fast, powerful, yet easy to use template engine. Converts templates into Go code and then compiles it. -
amber
Amber is an elegant templating engine for Go Programming Language It is inspired from HAML and Jade. -
Plush
Plush is the templating system that Go both needs and deserves. Powerful, flexible, and extendable, Plush is there to make writing your templates that much easier. -
fasttemplate
Simple and fast template engine. Substitutes template placeholders up to 10x faster than text/template. -
ego
A lightweight templating language that lets you write templates in Go. Templates are translated into Go and compiled. -
maroto
A maroto way to create PDFs. Maroto is inspired in Bootstrap and uses gofpdf. Fast and simple. -
goview
Goview is a lightweight, minimalist and idiomatic template library based on golang html/template for building Go web application. -
grender
small wrapper around html/template for file-based templates that support extending other template files -
damsel
Markup language featuring html outlining via css-selectors, extensible via pkg html/template and others. -
gospin
Article spinning and spintax/spinning syntax engine, useful for A/B, testing pieces of text/articles and creating more natural conversations.
Get performance insights in less than 4 minutes
Do you think we are missing an alternative of mustache or a related project?
README
Overview
mustache.go is an implementation of the mustache template language in Go. It is better suited for website templates than Go's native pkg/template. mustache.go is fast -- it parses templates efficiently and stores them in a tree-like structure which allows for fast execution.
Documentation
For more information about mustache, check out the mustache project page or the mustache manual.
Also check out some example mustache files
Installation
To install mustache.go, simply run go get github.com/hoisie/mustache
. To use it in a program, use import "github.com/hoisie/mustache"
Usage
There are four main methods in this package:
func Render(data string, context ...interface{}) string
func RenderFile(filename string, context ...interface{}) string
func ParseString(data string) (*Template, os.Error)
func ParseFile(filename string) (*Template, os.Error)
There are also two additional methods for using layouts (explained below).
The Render method takes a string and a data source, which is generally a map or struct, and returns the output string. If the template file contains an error, the return value is a description of the error. There's a similar method, RenderFile, which takes a filename as an argument and uses that for the template contents.
data := mustache.Render("hello {{c}}", map[string]string{"c":"world"})
println(data)
If you're planning to render the same template multiple times, you do it efficiently by compiling the template first:
tmpl,_ := mustache.ParseString("hello {{c}}")
var buf bytes.Buffer;
for i := 0; i < 10; i++ {
tmpl.Render (map[string]string { "c":"world"}, &buf)
}
For more example usage, please see mustache_test.go
Escaping
mustache.go follows the official mustache HTML escaping rules. That is, if you enclose a variable with two curly brackets, {{var}}
, the contents are HTML-escaped. For instance, strings like 5 > 2
are converted to 5 > 2
. To use raw characters, use three curly brackets {{{var}}}
.
Layouts
It is a common pattern to include a template file as a "wrapper" for other templates. The wrapper may include a header and a footer, for instance. Mustache.go supports this pattern with the following two methods:
func RenderInLayout(data string, layout string, context ...interface{}) string
func RenderFileInLayout(filename string, layoutFile string, context ...interface{}) string
The layout file must have a variable called {{content}}
. For example, given the following files:
layout.html.mustache:
<html>
<head><title>Hi</title></head>
<body>
{{{content}}}
</body>
</html>
template.html.mustache:
<h1> Hello World! </h1>
A call to RenderFileInLayout("template.html.mustache", "layout.html.mustache", nil)
will produce:
<html>
<head><title>Hi</title></head>
<body>
<h1> Hello World! </h1>
</body>
</html>
A note about method receivers
Mustache.go supports calling methods on objects, but you have to be aware of Go's limitations. For example, lets's say you have the following type:
type Person struct {
FirstName string
LastName string
}
func (p *Person) Name1() string {
return p.FirstName + " " + p.LastName
}
func (p Person) Name2() string {
return p.FirstName + " " + p.LastName
}
While they appear to be identical methods, Name1
has a pointer receiver, and Name2
has a value receiver. Objects of type Person
(non-pointer) can only access Name2
, while objects of type *Person
(person) can access both. This is by design in the Go language.
So if you write the following:
mustache.Render("{{Name1}}", Person{"John", "Smith"})
It'll be blank. You either have to use &Person{"John", "Smith"}
, or call Name2
Supported features
- Variables
- Comments
- Change delimiter
- Sections (boolean, enumerable, and inverted)
- Partials