Templates

Template Rendering

Context#Render(code int, name string, data interface{}) error renders a templatewith data and sends a text/html response with status code. Templates can be registered by setting Echo.Renderer, allowing us to use any template engine.

Example below shows how to use Go html/template:

  • Implement echo.Renderer interface
  1. type Template struct {
  2.     templates *template.Template
  3. }
  5. func (t *Template) Render(w io.Writer, name string, data interface{}, c echo.Context) error {
  6.     return t.templates.ExecuteTemplate(w, name, data)
  7. }
  • Pre-compile templates

public/views/hello.html

  1. {{define "hello"}}Hello, {{.}}!{{end}}
  1. t := &Template{
  2.     templates: template.Must(template.ParseGlob("public/views/*.html")),
  3. }
  • Register templates
  1. e := echo.New()
  2. e.Renderer = t
  3. e.GET("/hello", Hello)
  • Render a template inside your handler
  1. func Hello(c echo.Context) error {
  2.     return c.Render(http.StatusOK, "hello", "World")
  3. }

Advanced - Calling Echo from templates

In certain situations it might be useful to generate URIs from the templates. In order to do so, you need to call Echo#Reverse from the templates itself. Golang’s html/template package is not the best suited for this job, but this can be done in two ways: by providing a common method on all objects passed to templates or by passing map[string]interface{} and augmenting this object in the custom renderer. Given the flexibility of the latter approach, here is a sample program:

template.html

  1. <html>
  2.     <body>
  3.         <h1>Hello {{index . "name"}}</h1>
  5.         <p>{{ with $x := index . "reverse" }}
  6.            {{ call $x "foobar" }} &lt;-- this will call the $x with parameter "foobar"
  7.            {{ end }}
  8.         </p>
  9.     </body>
  10. </html>

server.go

  1. package main
  3. import (
  4.     "html/template"
  5.     "io"
  6.     "net/http"
  8.     "github.com/labstack/echo"
  9. )
  11. // TemplateRenderer is a custom html/template renderer for Echo framework
  12. type TemplateRenderer struct {
  13.     templates *template.Template
  14. }
  16. // Render renders a template document
  17. func (t *TemplateRenderer) Render(w io.Writer, name string, data interface{}, c echo.Context) error {
  19.     // Add global methods if data is a map
  20.     if viewContext, isMap := data.(map[string]interface{}); isMap {
  21.         viewContext["reverse"] = c.Echo().Reverse
  22.     }
  24.     return t.templates.ExecuteTemplate(w, name, data)
  25. }
  27. func main() {
  28.   e := echo.New()
  29.   renderer := &TemplateRenderer{
  30.       templates: template.Must(template.ParseGlob("*.html")),
  31.   }
  32.   e.Renderer = renderer
  34.   // Named route "foobar"
  35.   e.GET("/something", func(c echo.Context) error {
  36.       return c.Render(http.StatusOK, "something.html", map[string]interface{}{
  37.           "name": "Dolly!",
  38.       })
  39.   }).Name = "foobar"
  41.   e.Logger.Fatal(e.Start(":8000"))
  42. }