Documentation
Iris supports 7 template engines out-of-the-box, developers can still use any external golang template engine, as
Context.ResponseWriter() is an io.Writer.All template engines share a common API i.e. Parse using embedded assets, Layouts and Party-specific layout, Template Funcs, Partial Render and more.
# | Name | Parser |
|---|---|---|
1 | HTML | |
2 | Blocks | |
3 | Django | |
4 | Pug | |
5 | Handlebars | |
6 | Jet | |
7 | Ace |
A view engine can be registered per-Party. To register a view engine use the
Application/Party.RegisterView(ViewEngine) method as shown below.Load all templates from the "./views" folder where extension is ".html" and parse them using the standard
html/template package.// [app := iris.New...]
tmpl := iris.HTML("./views", ".html")
app.RegisterView(tmpl)
To render or execute a view use the
Context.View method inside the main route's handler. E.g. to load the ./views/hi.html template file:ctx.View("hi") // or hi.html
To bind Go values with key-value pattern inside a view through middleware or main handler use the
Context.ViewData method before the Context.View one.Bind:
{{.message}} with "Hello world!".ctx.ViewData("message", "Hello world!")
To bind a Go model to a view you have two options:
1.
ctx.ViewData("user", User{})
// variable binding as {{.user.Name}}
2.
ctx.View("user-page.html", User{})
// root binding as {{.Name}}
To add a template function use the
AddFunc method of the preferred view engine.// func name, input arguments, render value
tmpl.AddFunc("greet", func(s string) string {
return "Greetings " + s + "!"
})
To reload on each request set the view engine's
Reload method.tmpl.Reload(true)
To use embedded templates and not depend on local file system use the go-bindata external tool and pass its
Asset and AssetNames functions to the Binary method of the preferred view engine.tmpl.Binary(Asset, AssetNames)
Example Code:
Please read the comments too.
// file: main.go
package main
import "github.com/kataras/iris/v12"
func main() {
app := iris.New()
// Parse all templates from the "./views" folder
// where extension is ".html" and parse them
// using the standard `html/template` package.
tmpl := iris.HTML("./views", ".html")
// Enable re-build on local template files changes.
tmpl.Reload(true)
// Default template funcs are:
//
// - {{ urlpath "myNamedRoute" "pathParameter_ifNeeded" }}
// - {{ render "header.html" }}
// and partial relative path to current page:
// - {{ render_r "header.html" }}
// - {{ yield }}
// - {{ current }}
// Register a custom template func:
tmpl.AddFunc("greet", func(s string) string {
return "Greetings " + s + "!"
})
// Register the view engine to the views,
// this will load the templates.
app.RegisterView(tmpl)
// Method: GET
// Resource: http://localhost:8080
app.Get("/", func(ctx iris.Context) {
// Bind: {{.message}} with "Hello world!"
ctx.ViewData("message", "Hello world!")
// Render template file: ./views/hi.html
ctx.View("hi.html")
})
app.Listen(":8080")
}
<!-- file: ./views/hi.html -->
<html>
<head>
<title>Hi Page</title>
</head>
<body>
<h1>{{.message}}</h1>
<strong>{{greet "to you"}}</strong>
</body>
</html>
The rendered result will look like this:
<html>
<head>
<title>Hi Page</title>
</head>
<body>
<h1>Hello world!</h1>
<strong>Greetings to you!</strong>
</body>
</html>
Iris allows unlimited number of registered view engines per Application. Besides that, you can register a view engine per Party or through middleware too!.
// Register a view engine per group of routes.
adminGroup := app.Party("/admin")
adminGroup.RegisterView(iris.Blocks("./views/admin", ".html"))
func middleware(views iris.ViewEngine) iris.Handler {
return func(ctx iris.Context) {
ctx.ViewEngine(views)
ctx.Next()
}
}
Usage
// Register a view engine on-fly for the current chain of handlers.
views := iris.Blocks("./views/on-fly", ".html")
views.Load()
app.Get("/", setViews(views), onFly)
Last modified 12d ago