All template engines share a common API i.e. Parse using embedded assets, Layouts and Party-specific layout, Template Funcs, Partial Render and more.

    .

    List of Benchmarks.

    A view engine can be registered per-Party. To register a view engine use the Application/Party.RegisterView(ViewEngine) method as shown below.

    To render or execute a view use the Context.View method inside the main route’s handler.

    1. ctx.View("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!".

    1. ctx.ViewData("message", "Hello world!")

    Root binding:

    1. //       func name, input arguments, render value
    2. tmpl.AddFunc("greet", func(s string) string {
    3.     return "Greetings " + s + "!"
    4. })

    To reload on every request call the view engine’s Reload method.

    1. tmpl.Reload(true)

    To use embedded templates and not depend on local file system use the external tool and pass its AssetFile() generated function to the first input argument of the preferred view engine.

    Example Code:

    1. // file: main.go
    2. package main
    4. import "github.com/kataras/iris/v12"
    7.     app := iris.New()
    9.     // Parse all templates from the "./views" folder
    10.     // where extension is ".html" and parse them
    11.     // using the standard `html/template` package.
    12.     tmpl := iris.HTML("./views", ".html")
    13.     // Set custom delimeters.
    14.     // Enable re-build on local template files changes.
    15.     tmpl.Reload(true)
    17.     // Default template funcs are:
    18.     //
    19.     // - {{ urlpath "myNamedRoute" "pathParameter_ifNeeded" }}
    20.     // - {{ render "header.html" }}
    21.     // and partial relative path to current page:
    22.     // - {{ render_r "header.html" }} 
    23.     // - {{ yield }}
    24.     // - {{ current }}
    25.     // Register a custom template func:
    26.     tmpl.AddFunc("greet", func(s string) string {
    27.         return "Greetings " + s + "!"
    28.     })
    30.     // Register the view engine to the views,
    31.     // this will load the templates.
    32.     app.RegisterView(tmpl)
    34.     // Resource:  http://localhost:8080
    35.     app.Get("/", func(ctx iris.Context) {
    36.         // Bind: {{.message}} with "Hello world!"
    37.         ctx.ViewData("message", "Hello world!")
    38.         // Render template file: ./views/hi.html
    39.         ctx.View("hi.html")
    40.     })
    42.     app.Listen(":8080")
    43. }
    1. <!-- file: ./views/hi.html -->
    2. <html>
    3. <head>
    4.     <title>Hi Page</title>
    5. </head>
    6. <body>
    7.     <h1>{{.message}}</h1>
    8.     <strong>{{greet "to you"}}</strong>
    10. </html>

    Open a browser tab at http://localhost:8080.