• 《Go语言四十二章经》第三十五章 模板
    • 35.1 text/template
    • 35.2 html/template
    • 35.3 模板语法

    《Go语言四十二章经》第三十五章 模板

    作者：李骁

    Printf也可以做到输出格式化，当然，对于简单的例子来说足够了，但是我们有时候还是需要复杂的输出格式，甚至需要将格式化代码分离开来。这时，可以使用text/template和html/template。

    Go 官方库提供了两个模板库： text/template 和 html/template 。这两个库类似，当需要输出html格式的代码时需要使用 html/template。

    35.1 text/template

    所谓模板引擎，则将模板和数据进行渲染的输出格式化后的字符程序。对于Go，执行这个流程大概需要三步。

    • 创建模板对象
    • 加载模板
    • 执行渲染模板

    其中最后一步就是把加载的字符和数据进行格式化。

    1. package main
    3. import (
    4.     "log"
    5.     "os"
    6.     "text/template"
    7. )
    9. const templ = ` 
    10. {{range .}}----------------------------------------
    11. Name:   {{.Name}}
    12. Price:  {{.Price | printf "%4s"}}
    13. {{end}}`
    15. var report = template.Must(template.New("report").Parse(templ))
    17. type Book struct {
    18.     Name  string
    19.     Price float64
    20. }
    22. func main() {
    23.     Data := []Book{{"《三国演义》", 19.82}, {"《儒林外史》", 99.09}, {"《史记》", 26.89}}
    24.     if err := report.Execute(os.Stdout, Data); err != nil {
    25.         log.Fatal(err)
    26.     }
    27. }
    1. 程序输出：
    2. ----------------------------------------
    3. Name:   《三国演义》
    4. Price:  %!s(float64=19.82)
    5. ----------------------------------------
    6. Name:   《儒林外史》
    7. Price:  %!s(float64=99.09)
    8. ----------------------------------------
    9. Name:   《史记》
    10. Price:  %!s(float64=26.89)

    如果把模板的内容存在一个文本文件里tmp.txt：

    1. {{range .}}----------------------------------------
    2. Name:   {{.Name}}
    3. Price:  {{.Price | printf "%4s"}}
    4. {{end}}

    我们可以这样处理：

    1. package main
    3. import (
    4.     "log"
    5.     "os"
    6.     "text/template"
    7. )
    9. var report = template.Must(template.ParseFiles("tmp.txt"))
    11. type Book struct {
    12.     Name  string
    13.     Price float64
    14. }
    16. func main() {
    17.     Data := []Book{{"《三国演义》", 19.82}, {"《儒林外史》", 99.09}, {"《史记》", 26.89}}
    18.     if err := report.Execute(os.Stdout, Data); err != nil {
    19.         log.Fatal(err)
    20.     }
    21. }
    1. 程序输出：
    3. ----------------------------------------
    4. Name:   《三国演义》
    5. Price:  %!s(float64=19.82)
    6. ----------------------------------------
    7. Name:   《儒林外史》
    8. Price:  %!s(float64=99.09)
    9. ----------------------------------------
    10. Name:   《史记》
    11. Price:  %!s(float64=26.89)
    1. Tmpl, err := template.ParseFiles("tmp.txt")  
    2. //建立模板，自动 new("name")

    ParseFiles接受一个字符串，字符串的内容是一个模板文件的路径。

    ParseGlob是用正则的方式匹配多个文件。

    假设一个目录里有a.txt b.txt c.txt的话，用ParseFiles需要写3行对应3个文件，如果有更多文件，可以用ParseGlob。

    写成template.ParseGlob(“*.txt”) 即可。

    1. var report = template.Must(template.ParseFiles("tmp.txt"))

    函数Must，它的作用是检测模板是否正确，例如大括号是否匹配，注释是否正确的关闭，变量是否正确的书写。

    35.2 html/template

    和text、template类似，html/template主要在提供支持HTML的功能，所以基本使用上和上面差不多，我们来看下面代码：

    index.html：

    1. <!doctype html>
    2.  <head>
    3.   <meta charset="UTF-8">
    4.   <meta name="Author" content="">
    5.   <meta name="Keywords" content="">
    6.   <meta name="Description" content="">
    7.   <title>Go</title>
    8.  </head>
    9.  <body>
    10.    {{ . }} 
    11.  </body>
    12. </html>

    main.go：

    1. package main
    3. import (
    4.     "fmt"
    5.     "net/http"
    6.     "text/template"
    7. )
    9. func tHandler(w http.ResponseWriter, r *http.Request) {
    10.     t, _ := template.ParseFiles("index.html")
    11.     t.Execute(w, "Hello World!")
    12. }
    14. func main() {
    15.     http.HandleFunc("/", tHandler)
    16.     http.ListenAndServe(":8080", nil)
    17. }

    运行程序，在浏览器打开：http://localhost:8080/ 会看到页面显示Hello World!

    1. func(t *Template) ParseFiles(filenames ...string) (*Template, error)
    2. func(t *Template) ParseGlob(patternstring) (*Template, error)

    从上面代码中我们可以看到，通过ParseFile加载了单个Html模板文件。但最终的页面很可能是多个模板文件的嵌套结果。

    ParseFiles也支持加载多个模板文件，模板对象的名字则是第一个模板文件的文件名。

    ExecuteTemplate方法，用于执行指定名字的模板，下面我们根据一段代码来看看：

    Layout.html，注意在开头根据模板语法，定义了模板名字，define “layout”。
    在结尾处，通过 {{ template “index” }}

    注意：通过将模板应用于一个数据结构(即该数据结构作为模板的参数)来执行，来获得输出。模板执行时会遍历结构并将指针表示为.(称之为dot)，指向运行过程中数据结构的当前位置的值。

    {{template “header” .}} 嵌套模板中，加入.dot 代表在该模板中也可以使用该数据结构，否则不能显示。

    1. {{ define "layout" }}
    3. <!doctype html>
    4.  <head>
    5.   <meta charset="UTF-8">
    6.   <meta name="Author" content="">
    7.   <meta name="Keywords" content="">
    8.   <meta name="Description" content="">
    9.   <title>Go</title>
    10.  </head>
    11.  <body>
    12.    {{ . }} 
    14.    {{ template "index" }}
    15.  </body>
    16. </html>
    18. {{ end }}
    1. Index.html：
    3. {{ define "index" }}
    5. <div>
    6. <b>Index</b>
    7. </div>
    8. {{ end }}

    通过define定义模板，还可以通过template action引入模板，类似include。

    1. package main
    3. import (
    4.     "net/http"
    5.     "text/template"
    6. )
    8. func tHandler(w http.ResponseWriter, r *http.Request) {
    9.     t, _ := template.ParseFiles("layout.html", "index.html")
    10.     t.ExecuteTemplate(w, "layout", "Hello World!")
    11. }
    13. func main() {
    14.     http.HandleFunc("/", tHandler)
    15.     http.ListenAndServe(":8080", nil)
    16. }

    运行程序，在浏览器打开：http://localhost:8080/

    Hello World!
    Index

    1. 有关ParseGlob方法，则是通过glob通配符加载模板，例如 t, _ := template.ParseGlob("*.html")

    35.3 模板语法

    1. 【模板标签】
    2. 模板标签用"{{"和"}}"括起来
    4. 【注释】
    5. {{/* a comment */}}
    6. 使用"{{/*"和"*/}}"来包含注释内容
    8. 【变量】
    9. {{.}}
    10. 此标签输出当前对象的值
    11. {{.Admpub}}
    12. 表示输出Struct对象中字段或方法名称为"Admpub"的值。
    14. 当"Admpub"是匿名字段时，可以访问其内部字段或方法, 比如"Com"：{{.Admpub.Com}} ，
    15. 如果"Com"是一个方法并返回一个Struct对象，同样也可以访问其字段或方法：{{.Admpub.Com.Field1}}
    17. {{.Method1 "参数值1" "参数值2"}}
    18. 调用方法"Method1"，将后面的参数值依次传递给此方法，并输出其返回值。
    20. {{$admpub}}
    21. 此标签用于输出在模板中定义的名称为"admpub"的变量。当$admpub本身是一个Struct对象时，可访问其字段：{{$admpub.Field1}}
    22. 在模板中定义变量：变量名称用字母和数字组成，并带上"$"前缀，采用简式赋值。
    23. 比如：{{$x := "OK"}} 或 {{$x := pipeline}}
    1. 【通道函数】
    2. 用法1：
    3. {{FuncName1}}
    4. 此标签将调用名称为"FuncName1"的模板函数（等同于执行"FuncName1()"，不传递任何参数）并输出其返回值。
    5. 用法2：
    6. {{FuncName1 "参数值1" "参数值2"}}
    7. 此标签将调用FuncName1("参数值1", "参数值2")，并输出其返回值
    8. 用法3：
    9. {{.Admpub|FuncName1}}
    10. 此标签将调用名称为"FuncName1"的模板函数（等同于执行"FuncName1(this.Admpub)"，将竖线"|"左边的".Admpub"变量值作为函数参数传送）并输出其返回值。
    13. 【条件判断】
    14. 用法1：
    15. {{if pipeline}} T1 {{end}}
    16. 标签结构：{{if ...}} ... {{end}}
    17. 用法2：
    18. {{if pipeline}} T1 {{else}} T0 {{end}}
    19. 标签结构：{{if ...}} ... {{else}} ... {{end}}
    20. 用法3：
    21. {{if pipeline}} T1 {{else if pipeline}} T0 {{end}}
    22. 标签结构：{{if ...}} ... {{else if ...}} ... {{end}}
    23. 其中if后面可以是一个条件表达式（包括通道函数表达式。pipeline即通道），也可以是一个字符窜变量或布尔值变量。当为字符窜变量时，如为空字符串则判断为false，否则判断为true。
    1. 【遍历】
    2. 用法1：
    3. {{range $k, $v := .Var}} {{$k}} => {{$v}} {{end}}
    4. range...end结构内部如要使用外部的变量，比如.Var2，需要这样写：$.Var2
    5. （即：在外部变量名称前加符号"$"即可，单独的"$"意义等同于global）
    6. 用法2：
    7. {{range .Var}} {{.}} {{end}}
    8. 用法3：
    9. {{range pipeline}} T1 {{else}} T0 {{end}}
    10. 当没有可遍历的值时，将执行else部分。
    14. 【嵌入子模板】
    15. 用法1：
    16. {{template "name"}}
    17. 嵌入名称为"name"的子模板。使用前请确保已经用{{define "name"}}子模板内容{{end}}定义好了子模板内容。
    18. 用法2：
    19. {{template "name" pipeline}}
    20. 将通道的值赋给子模板中的"."（即"{{.}}"）
    22. 【子模板嵌套】
    23. {{define "T1"}}ONE{{end}}
    24. {{define "T2"}}TWO{{end}}
    25. {{define "T3"}}{{template "T1"}} {{template "T2"}}{{end}}
    26. {{template "T3"}}
    27. 输出：
    28. ONE TWO
    31. 【定义局部变量】
    32. 用法1：
    33. {{with pipeline}} T1 {{end}}
    34. 通道的值将赋给该标签内部的"."。（注：这里的“内部”一词是指被{{with pipeline}}...{{end}}包围起来的部分，即T1所在位置）
    35. 用法2：
    36. {{with pipeline}} T1 {{else}} T0 {{end}}
    37. 如果通道的值为空，"."不受影响并且执行T0，否则，将通道的值赋给"."并且执行T1。
    40. 说明：{{end}}标签是if、with、range的结束标签。
    43. 【例子：输出字符窜】
    44. {{"\"output\""}}
    45. 输出一个字符窜常量。
    47. {{`"output"`}}
    48. 输出一个原始字符串常量
    50. {{printf "%q" "output"}}
    51. 函数调用.（等同于：printf("%q", "output")。）
    53. {{"output" | printf "%q"}}
    54. 竖线"|"左边的结果作为函数最后一个参数。（等同于：printf("%q", "output")。）
    56. {{printf "%q" (print "out" "put")}}
    57. 圆括号中表达式的整体结果作为printf函数的参数。（等同于：printf("%q", print("out", "put"))。）
    59. {{"put" | printf "%s%s" "out" | printf "%q"}}
    60. 一个更复杂的调用。（等同于：printf("%q", printf("%s%s", "out", "put"))。）
    62. {{"output" | printf "%s" | printf "%q"}}
    63. 等同于：printf("%q", printf("%s", "output"))。
    65. {{with "output"}}{{printf "%q" .}}{{end}}
    66. 一个使用点号"."的with操作。（等同于：printf("%q", "output")。）
    68. {{with $x := "output" | printf "%q"}}{{$x}}{{end}}
    69. with结构，定义变量，值为执行通道函数之后的结果（等同于：$x := printf("%q", "output")。）
    71. {{with $x := "output"}}{{printf "%q" $x}}{{end}}
    72. with结构中，在其它动作中使用定义的变量
    74. {{with $x := "output"}}{{$x | printf "%q"}}{{end}}
    75. 同上，但使用了通道。（等同于：printf("%q", "output")。）
    3. ===============【预定义的模板全局函数】================
    4. 【and】
    5. {{and x y}}
    6. 表示：if x then y else x
    7. 如果x为真，返回y，否则返回x。等同于Go中的：x && y
    9. 【call】
    10. {{call .X.Y 1 2}}
    11. 表示：dot.X.Y(1, 2)
    12. call后面的第一个参数的结果必须是一个函数（即这是一个函数类型的值），其余参数作为该函数的参数。
    13. 该函数必须返回一个或两个结果值，其中第二个结果值是error类型。
    14. 如果传递的参数与函数定义的不匹配或返回的error值不为nil，则停止执行。
    16. 【html】
    17. 转义文本中的html标签，如将"<"转义为"&lt;"，">"转义为"&gt;"等
    19. 【index】
    20. {{index x 1 2 3}}
    21. 返回index后面的第一个参数的某个索引对应的元素值，其余的参数为索引值
    22. 表示：x[1][2][3]
    23. x必须是一个map、slice或数组
    25. 【js】
    26. 返回用JavaScript的escape处理后的文本
    28. 【len】
    29. 返回参数的长度值（int类型）
    31. 【not】
    32. 返回单一参数的布尔否定值。
    34. 【or】
    35. {{or x y}}
    36. 表示：if x then x else y。等同于Go中的：x || y
    37. 如果x为真返回x，否则返回y。
    39. 【print】
    40. fmt.Sprint的别名
    42. 【printf】
    43. fmt.Sprintf的别名
    45. 【println】
    46. fmt.Sprintln的别名
    48. 【urlquery】
    49. 返回适合在URL查询中嵌入到形参中的文本转义值。（类似于PHP的urlencode）
    2. =================【布尔函数】===============
    4. 布尔函数对于任何零值返回false，非零值返回true。
    5. 这里定义了一组二进制比较操作符函数：
    7. 【eq】
    8. 返回表达式"arg1 == arg2"的布尔值
    10. 【ne】
    11. 返回表达式"arg1 != arg2"的布尔值
    13. 【lt】
    14. 返回表达式"arg1 < arg2"的布尔值
    16. 【le】
    17. 返回表达式"arg1 <= arg2"的布尔值
    19. 【gt】
    20. 返回表达式"arg1 > arg2"的布尔值
    22. 【ge】
    23. 返回表达式"arg1 >= arg2"的布尔值
    25. 对于简单的多路相等测试，eq只接受两个参数进行比较，后面其它的参数将分别依次与第一个参数进行比较，
    26. {{eq arg1 arg2 arg3 arg4}}
    27. 即只能作如下比较：
    28. arg1==arg2 || arg1==arg3 || arg1==arg4 ...