1. 模板渲染
Golang为模板操作提供了丰富的支持，嵌套模板、导入函数、表示变量、迭代数据等都很简单。若需要比CSV数据格式更复杂的电脑关系，模板可能是一个不错的解决方案。模板的另一个 应用是网站的页面渲染。
Golang内置text/template和html/template两个模板库，html/template库为HTML提供了完整的支持，包括普通变量渲染、列表渲染、对象渲染等。
text/template是Golang标准库，实现数据驱动模板以生成文本输出，可理解为一组文本按照特定格式嵌套动态嵌入另一组文本中。可用来开发代码生成器。
text/template包是数据驱动的文本输出模板，即在编写好的模板中填充数据。一般而言，模板使用流程分为三个步骤：定义模板、解析模板、数据驱动模板。
|
1 |
$ vim main.go |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
package main import ( "os" "text/template" ) func main() { //创建模板 id := 100 tmpl, err := template.New("tplname").Parse("id = {{.}}") if err != nil { panic(err) } //模板合并输出 err = tmpl.Execute(os.Stdout, id) if err != nil { panic(err) } } |
|
1 2 |
$ go run main.go id = 100 |
- {{.}}中.点号表示传入模板的数据，数据不同渲染不同。
- .点可代表Golang的任何类型，比如Struct、Map等。
- {{和}}包裹的内容统称为Actions,这部分将在第三章描述。
2. Golang模板库text/template使用
本章主要讨论golang后端的模板读取及渲染方法。
2.1. template基础
func ParseFiles(filenames ...string) (*Template, error)-> 用于创建一个模板并解析filenames指定的文件里面的模板定义。返回的模板的名字是第一个文件的文件名(不含扩展名)，内容为解析后的第一个文件的内容。如果发生错误，会停止解析并返回nil。func New(name string) *Template-> 用于创建一个名为name的模板func ParseGlob(pattern string) (*Template, error)-> 创建一个模板并解析匹配pattern的文件(参见glob规则)里的模板定义。返回的模板的名字是第一个匹配的文件名(不含扩展名)，内容为解析后的第一个文件的内容。至少条存在一个匹配的文件，如果发生错误，将会停止解析并返回nil。ParseGlob等价于使用匹配pattern的文件的列表为参数调用ParseFiles.func Must(t *Template, err error) *Template-> Must函数用于包装返回(*Template,error)的函数/方法调用，它会在err非nil时panic,一般用于变量初始化
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
type Template struct{ *parse.Tree // 内含隐藏或非导出字段 } // 方法 func (t *Template) Parse(text string) (*Template, error) //将字符串text解析成模板，嵌套定义的模板会关联到最顶层的t。Parse可以多次调用，但只有第一次调用可以包含空格、注释和模板定义之外的文本。如果后面的调用在解析后仍剩余文本会引发错误，返回nil且丢弃剩余文本；如果解析得到的模板已有相关联的同名模板，会覆盖掉原模板 func (t *Template) Name() string // 返回模板t的名字 func (t *Template) Delims(left, right string) *Template // Delims方法用于设置action的分界字符串，应用于之后的Parse、ParseFiles、ParseGlob方法。嵌套模板定义会继承这种分界符设置。空字符串分界符表示相应的默认分界符：{{或}}。返回值就是t，以便进行链式调用。 func (t *Template) Execute(wr io.Writer, data interface{}) (err error) // Execute方法将解析好的模板应用到data上，并将输出写入wr,如果执行时出现错误，会停止执行，但有可能已经写入wr部分数据。模板可以安全并发执行。 func (t *Template) ExecuteTemplate(wr io.Writer, name string, data interface{}) error // 类似Execute，但是使用名为name的t关联的模板产生输出 |
2.2. template.New
|
1 |
func New(name string) *Template |
template.New()创建名为name的模板
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 |
package main import ( "os" "text/template" ) func main() { //模板变量 type User struct { Id int Name string } user := User{100, "admin"} //创建模板 tplname := "user" tmpl := template.New(tplname) //解析模板 text := "id = {{.Id}} name = {{.Name}}" tpl, err := tmpl.Parse(text) if err != nil { panic(err) } //渲染输出 err = tpl.Execute(os.Stdout, user) if err != nil { panic(err) } } |
|
1 2 |
$ go run main.go id = 100 name = admin |
2.3. template.Parse
|
1 |
func (t *Template) Parse(text string) (*Template, error) |
template.Parse()方法将字符串text解析为模板，嵌套定义的模板会关联到最顶层t。
template.Parse()可以多次调用，但只有第一次调用可以包含空格、注释、模板定义之外的文本。若后续调用解析后仍剩余文本会引发错误、返回nil、丢弃剩余文本。若解析得到的模板已有相关联的同名模板则会覆盖原模板。
2.4. template.ParseFiles
ParseFiles方法接收 一个字符串，字符串的内容是一个模板文件的路径，可为绝对路径或相对路径。
- 编辑模板文件
|
1 2 |
$ vim view/default.html id = {{.Id}} name = {{.Name}} |
- 解析模板文件
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
//main.go package main import ( "os" "text/template" ) func main() { //模板变量 type User struct { Id int Name string } user := User{100, "admin"} //创建模板 tmpl, err := template.ParseFiles("./view/default.html") if err != nil { panic(err) } //模板合并输出 err = tmpl.Execute(os.Stdout, user) if err != nil { panic(err) } } |
|
1 2 |
$ go run main.go id = 100 name = admin |
2.5. template.ExecuteTemplate
多模板时指定模板
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 |
package main import ( "os" "text/template" ) func main() { //模板变量 type User struct { Id int Name string } user := User{100, "admin"} //创建模板 tplname := "tplname" tmpl := template.New(tplname) //解析模板 text := "id = {{.Id}} name = {{.Name}}" tpl, err := tmpl.Parse(text) if err != nil { panic(err) } //渲染输出 err = tpl.ExecuteTemplate(os.Stdout, tplname, user) if err != nil { panic(err) } } |
2.6. template.Execute
template.Execute()方法将解析好的模板应用到data，并将输出写入wr。若执行时出现错误则会停止执行，但 有可能已经写入部分数据，模板可以安全的并发执行。
|
1 |
func (t *Template) Execute(wr io.Writer, data interface{}) (err error) |
- 输出到指定文件
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 |
package main import ( "os" "text/template" ) func main() { //模板变量 type User struct { Id int Name string } user := User{100, "admin"} //创建模板 tplname := "tplname" tmpl := template.New(tplname) //解析模板 text := "id = {{.Id}} name = {{.Name}}" tpl, err := tmpl.Parse(text) if err != nil { panic(err) } //输出文件 file, err := os.OpenFile("./public/tpl.txt", os.O_CREATE|os.O_WRONLY, 0755) if err != nil { panic(err) } //渲染输出 err = tpl.Execute(file, user) if err != nil { panic(err) } } |
- 读取模板文件解析后输出到指定位置
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 |
package main import ( "os" "text/template" ) func main() { //模板变量 type User struct { Id int Name string } user := User{100, "admin"} //解析模板 tplFile := "./view/default.html" tpl, err := template.ParseFiles(tplFile) if err != nil { panic(err) } //输出文件 outFile := "./runtime/view/default.html" file, err := os.OpenFile(outFile, os.O_CREATE|os.O_WRONLY, 0755) if err != nil { panic(err) } //渲染输出 err = tpl.Execute(file, user) if err != nil { panic(err) } } |
3. 模板入门
在写动态页面的网站的时候，我们常常将不变的部分提出成为模板，可变部分通过后端程序的渲染来生成动态网页，golang提供了html/template包来支持模板渲染。
本章重点讨论模板中嵌入变量，渲染变量、循环等一些基本用法。
3.1. 模板Action
模板的输入文本是任何格式的UTF-8编码文本，action可分为两种：
- 数据求值（data evaluations）
action数据求值的结果会直接复制到模板中 - 控制结构（control structures）
action控制结构和Golang程序类似，也是条件语句、循环语句、变量、函数调用等...
将模板成功解析后可安全地在并发环境中使用，若输出到同一个io.Writer数据可能会重叠，不能保证并发执行的先后顺序。
3.2. 数据求值
在golang渲染template的时候，可以接受一个interface{}类型的变量，我们在模板文件中可以读取变量内的值并渲染到模板里。
有两个常用的传入参数的类型。一个是struct，在模板内可以读取该struct域的内容来进行渲染。还有一个是map[string]interface{}，在模板内可以使用key来进行渲染。
通常使用第二种，效率可能会差一点儿，但是用着方便。
模板内内嵌的语法支持，全部需要加{{}}来标记。
在模板文件内， . 代表了当前变量，即在非循环体内，.就代表了传入的那个变量。假设我们定义了一个结构体：
|
1 2 3 4 |
type Article struct { ArticleId int ArticleContent string } |
那么我们在模板内可以通过
|
1 |
<p>{{.ArticleContent}}<span>{{.ArticleId}}</span></p> |
来获取并把变量的内容渲染到模板内。假设上述的结构体的内容为ArticleId:1 ArticleContent:”hello”， 则对应渲染后的模板内容为：
|
1 |
<p>hello<span>1</span></p> |
是不是很简单呢。
当然，我们有时候需要定义变量，比如我们需要定义一个article变量，同时将其初始化为”hello”，那么我们可以这样写：
|
1 |
{{$article := "hello"}} |
假设我们想要把传入值的内容赋值给article，则可以这样写：
|
1 |
{{$article := .ArticleContent}} |
这样我们只要使用{{$article}}则可以获取到这个变量的内容。
3.3. 控制结构
3.3.1. 模板函数
golang的模板其实功能很有限，很多复杂的逻辑无法直接使用模板语法来表达，所以只能使用模板函数来绕过。
首先，template包创建新的模板的时候，支持.Funcs方法来将自定义的函数集合导入到该模板中，后续通过该模板渲染的文件均支持直接调用这些函数。
该函数集合的定义为：
|
1 |
type FuncMap map[string]interface{} |
key为方法的名字，value则为函数。这里函数的参数个数没有限制，但是对于返回值有所限制。有两种选择，一种是只有一个返回值，还有一种是有两个返回值，但是第二个返回值必须是error类型的。这两种函数的区别是第二个函数在模板中被调用的时候，假设模板函数的第二个参数的返回不为空，则该渲染步骤将会被打断并报错。
在模板文件内，调用方法也非常的简单：
|
1 |
{{funcname .arg1 .arg2}} |
假设我们定义了一个函数
|
1 2 3 |
func add(left int, right int)s int{ s = left+right } |
则在模板文件内，通过调用
|
1 |
{{add 1 2}} |
就可以获得
|
1 |
3 |
这个结果，golang的预定义函数没有add，所以有点儿麻烦。
3.3.2. 判断
golang的模板也支持if的条件判断，当前支持最简单的bool类型和字符串类型的判断
|
1 2 |
{{if .condition}} {{end}} |
当.condition为bool类型的时候，则为true表示执行，当.condition为string类型的时候，则非空表示执行。
当然也支持else ， else if嵌套
|
1 2 3 |
{{if .condition1}} {{else if .contition2}} {{end}} |
假设我们需要逻辑判断，比如与或、大小不等于等判断的时候，我们需要一些内置的模板函数来做这些工作，目前常用的一些内置模板函数有：
- not 非
|
1 2 |
{{if not .condition}} {{end}} |
- and 与
|
1 2 |
{{if and .condition1 .condition2}} {{end}} |
- or 或
|
1 2 |
{{if or .condition1 .condition2}} {{end}} |
- eq 等于
|
1 2 |
{{if eq .var1 .var2}} {{end}} |
- ne 不等于
|
1 2 |
{{if ne .var1 .var2}} {{end}} |
- lt 小于 (less than)
|
1 2 |
{{if lt .var1 .var2}} {{end}} |
- le 小于等于
|
1 2 |
{{if le .var1 .var2}} {{end}} |
- t 大于
|
1 2 |
{{if gt .var1 .var2}} {{end}} |
- ge 大于等于
|
1 2 |
{{if ge .var1 .var2}} {{end}} |
3.3.3. 循环
golang的template支持range循环来遍历map、slice内的内容，语法为：
|
1 2 |
{{range $i, $v := .slice}} {{end}} |
在这个range循环内，我们可以通过iiv来访问遍历的值，还有一种遍历方式为：
|
1 2 |
{{range .slice}} {{end}} |
这种方式无法访问到index或者key的值，需要通过.来访问对应的value
|
1 2 3 |
{{range .slice}} {{.field}} {{end}} |
当然这里使用了.来访问遍历的值，那么我们想要在其中访问外部的变量怎么办？(比如渲染模板传入的变量)，在这里，我们需要使用$.来访问外部的变量
|
1 2 3 |
{{range .slice}} {{$.ArticleContent}} {{end}} |
3.3.4. 模板的嵌套
在编写模板的时候，我们常常将公用的模板进行整合，比如每一个页面都有导航栏和页脚，我们常常将其编写为一个单独的模块，让所有的页面进行导入，这样就不用重复的编写了。
任何网页都有一个主模板，然后我们可以在主模板内嵌入子模板来实现模块共享。
当模板想要引入子模板的时候，我们使用以下语句：
|
1 |
{{template "navbar"}} |
这样子就会尝试载入名称为navbar的子模板，同时我们也得定义一个子模板来实现”navbar”这个子模板。
子模板的定义为：
|
1 2 |
{{define "navbar"}} {{end}} |
在定义之间的内容将会覆盖{{template “navbar”}}
当然子模板是分离了，那么子模板能否获得父模板的变量呢？这是当然的，我们只需要使用
|
1 |
{{template "navbar" .}} |
就可以将当前的变量传给子模板了，这个也是相当方便的。
3.4. 结构体渲染模板示例
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 |
var htmlTemplate = ` <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=utf-8"> <title>AAAA</title> <style type="text/css"> table { border-collapse: collapse; margin: 0 auto; text-align: center; width: 100% } table td, table th { border: 1px solid #cad9ea; color: #666; height: 30px; } table thead th { background-color: #CCE8EB; width: 100px; } table tr:nth-child(odd) { background: #fff; } table tr:nth-child(even) { background: #F5FAFA; } </style> </head> <body> <table> {{ range .Protocols }} <tr><td>{{ .Name }}</td><td>{{ .DefaultPorts }}</td><td><a href="{{ .RefererURL }}">{{ .RefererURL }}</a></td><td>{{ .Weight }}</td></tr>{{ end }} </table> <table> {{ range $key, $value := .PortMap }} <tr><td>{{ $key }}</td><td>{{ len $value }}</td><td>{{ range $value }} {{ .Name }}, {{ end }}</td></tr>{{ end }} </table> </body> </html>` |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
func exportHtml(file string) { tmpl := template.New("tmpl1") tmpl.Parse(htmlTemplate) fi, err := os.OpenFile(file, os.O_RDWR|os.O_CREATE, 0755) if err != nil { panic(err) } defer fi.Close() info := struct { Protocols []probe.BaseProtocol PortMap mygrab.Ppmap }{ Protocols: probe.Protocols.BaseProtocols, PortMap: mygrab.GrabManager.PortProtoMap.Ppmap, } tmpl.Execute(fi, info) } |
4. 参考文档
赞赏
微信赞赏
支付宝赞赏