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.
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
Pass Data
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)
Embedded
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")
}
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"))
// 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)
