• 《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
    2. import (
    3. "log"
    4. "os"
    5. "text/template"
    6. )
    7. const templ = `
    8. {{range .}}----------------------------------------
    9. Name: {{.Name}}
    10. Price: {{.Price | printf "%4s"}}
    11. {{end}}`
    12. var report = template.Must(template.New("report").Parse(templ))
    13. type Book struct {
    14. Name string
    15. Price float64
    16. }
    17. func main() {
    18. Data := []Book{{"《三国演义》", 19.82}, {"《儒林外史》", 99.09}, {"《史记》", 26.89}}
    19. if err := report.Execute(os.Stdout, Data); err != nil {
    20. log.Fatal(err)
    21. }
    22. }
    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
    2. import (
    3. "log"
    4. "os"
    5. "text/template"
    6. )
    7. var report = template.Must(template.ParseFiles("tmp.txt"))
    8. type Book struct {
    9. Name string
    10. Price float64
    11. }
    12. func main() {
    13. Data := []Book{{"《三国演义》", 19.82}, {"《儒林外史》", 99.09}, {"《史记》", 26.89}}
    14. if err := report.Execute(os.Stdout, Data); err != nil {
    15. log.Fatal(err)
    16. }
    17. }
    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)
    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
    2. import (
    3. "fmt"
    4. "net/http"
    5. "text/template"
    6. )
    7. func tHandler(w http.ResponseWriter, r *http.Request) {
    8. t, _ := template.ParseFiles("index.html")
    9. t.Execute(w, "Hello World!")
    10. }
    11. func main() {
    12. http.HandleFunc("/", tHandler)
    13. http.ListenAndServe(":8080", nil)
    14. }

    运行程序,在浏览器打开: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" }}
    2. <!doctype html>
    3. <head>
    4. <meta charset="UTF-8">
    5. <meta name="Author" content="">
    6. <meta name="Keywords" content="">
    7. <meta name="Description" content="">
    8. <title>Go</title>
    9. </head>
    10. <body>
    11. {{ . }}
    12. {{ template "index" }}
    13. </body>
    14. </html>
    15. {{ end }}
    1. Index.html
    2. {{ define "index" }}
    3. <div>
    4. <b>Index</b>
    5. </div>
    6. {{ end }}

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

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

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

    Hello World!
    Index

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

    35.3 模板语法

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