quicktemplate

quicktemplate介绍

Go的快速，强大且易于使用的模板引擎。 针对热路径中的速度，零内存分配进行了优化。比html/template快20倍，灵感来自Mako templates

  • 非常快。 模板转换为Go代码然后编译
  • Quicktemplate语法非常接近Go - 在开始使用quicktemplate之前无需学习另一种模板语言
  • 在模板编译期间几乎所有错误都被捕获，因此生产受模板相关错误的影响较小
  • 使用方便。有关详细信息，请参阅快速入门和示例
  • 强大。任意Go代码可以嵌入到模板中并与模板混合。小心这个功能 - 不要从模板中查询数据库and/or外部资源，除非你错过Go中的PHP方式:)这种功能主要用于任意数据转换
  • 易于使用的模板继承由Go接口提供支持。 请参阅此示例以获取详细信
  • 模板被编译为单个二进制文件，因此无需将模板文件复制到服务器

模板无法在服务器上动态更新，因为它们被编译为单个二进制文件。如果您需要快速模板引擎来简单动态更新模板，请查看fasttemplate

quicktemplate使用

首先，安装quicktemplate包和quicktemplate compiler

  1. go get -u github.com/valyala/quicktemplate
  2. go get -u github.com/valyala/quicktemplate/qtc

可以在https://github.com/valyala/quicktemplate找到完整的文档。

将模板文件保存到扩展名*.qtpl下的templates文件夹中，打开终端并在此文件夹中运行qtc。

如果一切顺利，.qtpl.go文件必须出现在templates文件夹中。 这些文件包含所有 .qtpl文件的Go代码。

请记住，每次更改/templates/*.qtpl文件时，都必须运行qtc命令并重新构建应用程序。

目录结构

主目录herotemplate

  1.     —— controllers
  2.         —— execute_template.go
  3.         —— hello.go
  4.         —— index.go
  5.     —— template
  6.         —— base.qtpl
  7.         —— hello.qtpl
  8.         —— index.qtpl
  9.     —— main.go
  10.     —— main_test.go

代码示例

/controllers/execute_template.go

  1. package controllers
  3. import (
  4.     "../templates"
  5.     "github.com/kataras/iris"
  6. )
  7. // ExecuteTemplate将“tmpl”部分模板渲染给`context＃ResponseWriter`。
  8. func ExecuteTemplate(ctx iris.Context, tmpl templates.Partial) {
  9.     ctx.Gzip(true)
  10.     ctx.ContentType("text/html")
  11.     templates.WriteTemplate(ctx.ResponseWriter(), tmpl)
  12. }

文件名 /controllers/hello.go

  1. package controllers
  3. import (
  4.     "../templates"
  5.     "github.com/kataras/iris"
  6. )
  7. // Hello使用已编译的../templates/hello.qtpl.go文件渲染我们的../templates/hello.qtpl文件。
  8. func Hello(ctx iris.Context) {
  9.     // vars := make(map[string]interface{})
  10.     // vars["message"] = "Hello World!"
  11.     // vars["name"] = ctx.Params().Get("name")
  12.     // [...]
  13.     // &templates.Hello{ Vars: vars }
  14.     // [...]
  15.     //但是，作为替代方案，我们建议您使用`ctx.ViewData(key，value)`
  16.     //为了能够从中间件（其他处理程序）修改`templates.Hello #Vars`
  17.     ctx.ViewData("message", "Hello World!")
  18.     ctx.ViewData("name", ctx.Params().Get("name"))
  19.     // set view data to the `Vars` template's field
  20.     tmpl := &templates.Hello{
  21.         Vars: ctx.GetViewData(),
  22.     }
  23.     //渲染模板
  24.     ExecuteTemplate(ctx, tmpl)
  25. }

文件名 /controllers/index.go

  1. package controllers
  3. import (
  4.     "../templates"
  5.     "github.com/kataras/iris"
  6. )
  7. //索引使用已编译的../templates/index.qtpl.go文件渲染我们的../templates/index.qtpl文件。
  8. func Index(ctx iris.Context) {
  9.     tmpl := &templates.Index{}
  10.     //渲染模板
  11.     ExecuteTemplate(ctx, tmpl)
  12. }

/templates/base.qtpl

  2. 这是我们模板的基础实现
  3. {% interface
  4. Partial {
  5.     Body()
  6. }
  7. %}
  8. 模板编写实现Partial接口的模板
  9. {% func Template(p Partial) %}
  10. <html>
  11.     <head>
  12.         <title>Quicktemplate integration with Iris</title>
  13.     </head>
  14.     <body>
  15.         <div>
  16.             Header contents here...
  17.         </div>
  18.         <div style="margin:10px;">
  19.             {%= p.Body() %}
  20.         </div>
  21.     </body>
  22.     <footer>
  23.         Footer contents here...
  24.     </footer>
  25. </html>
  26. {% endfunc %}
  27. 基本模板实现。 如果需要，其他页面可以继承
  28. 仅覆盖某些部分方法。
  29. {% code type Base struct {} %}
  30. {% func (b *Base) Body() %}This is the base body{% endfunc %}

文件名 hello.qtpl

  2. Hello模板，实现了Partial的方法
  3. {% code
  4. type Hello struct {
  5.   Vars map[string]interface{}
  6. }
  7. %}
  8. {% func (h *Hello) Body() %}
  9.     <h1>{%v h.Vars["message"] %}</h1>
  10.     <div>
  11.         Hello <b>{%v h.Vars["name"] %}!</b>
  12.     </div>
  13. {% endfunc %}

/templates/index.qtpl

  1. Hello模板，实现了Partial的方法。
  2. {% code
  3. type Index struct {}
  4. %}
  5. {% func (i *Index) Body() %}
  6.     <h1>Index Page</h1>
  7.     <div>
  8.         This is our index page's body.
  9.     </div>
  10. {% endfunc %}

main.go

  1. package main
  3. import (
  4.     "./controllers"
  5.     "github.com/kataras/iris"
  6. )
  8. func newApp() *iris.Application {
  9.     app := iris.New()
  10.     app.Get("/", controllers.Index)
  11.     app.Get("/{name}", controllers.Hello)
  12.     return app
  13. }
  15. func main() {
  16.     app := newApp()
  17.     // http://localhost:8080
  18.     // http://localhost:8080/yourname
  19.     app.Run(iris.Addr(":8080"), iris.WithoutServerError(iris.ErrServerClosed))
  20. }

main_test.go

  1. package main
  3. import (
  4.     "fmt"
  5.     "testing"
  6.     "github.com/kataras/iris/httptest"
  7. )
  9. func TestResponseWriterQuicktemplate(t *testing.T) {
  10.     baseRawBody := `
  11. <html>
  12.     <head>
  13.         <title>Quicktemplate integration with Iris</title>
  14.     </head>
  15.     <body>
  16.         <div>
  17.             Header contents here...
  18.         </div>
  19.         <div style="margin:10px;">
  20.     <h1>%s</h1>
  21.     <div>
  22.         %s
  23.     </div>
  24.         </div>
  25.     </body>
  26.     <footer>
  27.         Footer contents here...
  28.     </footer>
  29. </html>
  30. `
  31.     expectedIndexRawBody := fmt.Sprintf(baseRawBody, "Index Page", "This is our index page's body.")
  32.     name := "yourname"
  33.     expectedHelloRawBody := fmt.Sprintf(baseRawBody, "Hello World!", "Hello <b>"+name+"!</b>")
  34.     app := newApp()
  35.     e := httptest.New(t, app)
  36.     e.GET("/").Expect().Status(httptest.StatusOK).Body().Equal(expectedIndexRawBody)
  37.     e.GET("/" + name).Expect().Status(httptest.StatusOK).Body().Equal(expectedHelloRawBody)
  38. }