Go模板template用法详解_Golang_

本文只介绍template的语法和用法，关于template包的函数、方法、template的结构和原理，见：深入解析Go template模板使用详解。

入门示例

以下为test.html文件的内容，里面使用了一个template语法{{.}}。

 {{ . }} 

以下是test.html同目录下的一个go web程序：

package main import ( "html/template" "net/http" ) func tmpl(w http.ResponseWriter, r *http.Request) { t1, err := template.ParseFiles("test.html") if err != nil { panic(err) } t1.Execute(w, "hello world") } func main() { server := http.Server{ Addr: "127.0.0.1:8080", } http.HandleFunc("/tmpl", tmpl) server.ListenAndServe() } 

前面的html文件中使用了一个template的语法{{.}}，这部分是需要通过go的template引擎进行解析，然后替换成对应的内容。

在go程序中，handler函数中使用template.ParseFiles("test.html")，它会自动创建一个模板(关联到变量t1上)，并解析一个或多个文本文件(不仅仅是html文件)，解析之后就可以使用Execute(w,"hello world")去执行解析后的模板对象，执行过程是合并、替换的过程。例如上面的{{.}}中的.会替换成当前对象"hello world"，并和其它纯字符串内容进行合并，最后写入w中，也就是发送到浏览器"hello world"。

本文不解释这些template包的函数、方法以及更底层的理论知识，本文只解释template的语法，如果觉得这些无法理解，或者看不懂官方手册，请看深入解析Go template模板使用详解。

关于点"."和作用域

在写template的时候，会经常用到"."。比如{{.}}、{{len .}}、{{.Name}}、{{$x.Name}}等等。

在template中，点"."代表当前作用域的当前对象。它类似于java/c++的this关键字，类似于perl/python的self。如果了解perl，它更可以简单地理解为默认变量$_。

例如，前面示例test.html中{{.}}，这个点是顶级作用域范围内的，它代表Execute(w,"hello worold")的第二个参数"hello world"。也就是说它代表这个字符串对象。

再例如，有一个Person struct。

type Person struct { Name string Age int } func main(){ p := Person{"longshuai",23} tmpl, _ := template.New("test").Parse("Name: {{.Name}}, Age: {{.Age}}") _ = tmpl.Execute(os.Stdout, p) } 

这里{{.Name}}和{{.Age}}中的点"."代表的是顶级作用域的对象p，所以Execute()方法执行的时候，会将{{.Name}}替换成p.Name，同理{{.Age}}替换成{{p.Age}}。

但是并非只有一个顶级作用域，range、with、if等内置action都有自己的本地作用域。它们的用法后文解释，这里仅引入它们的作用域来解释"."。

例如下面的例子，如果看不懂也没关系，只要从中理解"."即可。

package main import ( "os" "text/template" ) type Friend struct { Fname string } type Person struct { UserName string Emails []string Friends []*Friend } func main() { f1 := Friend{Fname: "xiaofang"} f2 := Friend{Fname: "wugui"} t := template.New("test") t = template.Must(t.Parse( `hello {{.UserName}}! {{ range .Emails }} an email {{ . }} {{- end }} {{ with .Friends }} {{- range . }} my friend name is {{.Fname}} {{- end }} {{ end }}`)) p := Person{UserName: "longshuai", Emails: []string{"a1@qq.com", "a2@gmail.com"}, Friends: []*Friend{&f1, &f2}} t.Execute(os.Stdout, p) } 

输出结果：

hello longshuai! an email a1@qq.com an email a2@gmail.com my friend name is xiaofang my friend name is wugui 

这里定义了一个Person结构，它有两个slice结构的字段。在Parse()方法中：

• 顶级作用域的{{.UserName}}、{{.Emails}}、{{.Friends}}中的点都代表Execute()的第二个参数，也就是Person对象p，它们在执行的时候会分别被替换成p.UserName、p.Emails、p.Friends。
• 因为Emails和Friend字段都是可迭代的，在{{range .Emails}}...{{end}}这一段结构内部an email {{.}}，这个"."代表的是range迭代时的每个元素对象，也就是p.Emails这个slice中的每个元素。
• 同理，with结构内部{{range .}}的"."代表的是p.Friends，也就是各个，再此range中又有一层迭代，此内层{{.Fname}}的点代表Friend结构的实例，分别是&f1和&f2，所以{{.Fname}}代表实例对象的Fname字段。

去除空白

template引擎在进行替换的时候，是完全按照文本格式进行替换的。除了需要评估和替换的地方，所有的行分隔符、空格等等空白都原样保留。所以，对于要解析的内容，不要随意缩进、随意换行。

可以在{{符号的后面加上短横线并保留一个或多个空格"- "来去除它前面的空白(包括换行符、制表符、空格等)，即{{- xxxx。

在}}的前面加上一个或多个空格以及一个短横线"-"来去除它后面的空白，即xxxx -}}。

例如：

{{23}} < {{45}} -> 23 < 45 {{23}} < {{- 45}} -> 23 <45 {{23 -}} < {{45}} -> 23< 45 {{23 -}} < {{- 45}} -> 23<45 

其中{{23 -}}中的短横线去除了这个替换结构后面的空格，即}} <中间的空白。同理{{- 45}}的短横线去除了< {{中间的空白。

再看上一节的例子中：

t.Parse( `hello {{.UserName}}! {{ range .Emails }} an email {{ . }} {{- end }} {{ with .Friends }} {{- range . }} my friend name is {{.Fname}} {{- end }} {{ end }}`) 

注意，上面没有进行缩进。因为缩进的制表符或空格在替换的时候会保留。

第一行和第二行之间输出时会换行输出，不仅如此，range {{.Emails}}自身也占一行，在替换的时候它会被保留为空行。除非range前面没加{{-。由于range的{{- end加上了去除前缀空白，所以每次迭代的时候，每个元素之间都换行输出但却不多一空行，如果这里的end去掉{{-，则每个迭代的元素之间输出的时候都会有空行。同理后面的with和range。

注释

注释方式：{{/* a comment */}}。

注释后的内容不会被引擎进行替换。但需要注意，注释行在替换的时候也会占用行，所以应该去除前缀和后缀空白，否则会多一空行。

{{- /* a comment without prefix/suffix space */}} {{/* a comment without prefix/suffix space */ -}} {{- /* a comment without prefix/suffix space */ -}} 

注意，应该只去除前缀或后缀空白，不要同时都去除，否则会破坏原有的格式。例如：

t.Parse( `hello {{.UserName}}! {{- /* this line is a comment */}} {{ range .Emails }} an email {{ . }} {{- end }} 

管道pipeline

pipeline是指产生数据的操作。比如{{.}}、{{.Name}}、funcname args等。

可以使用管道符号|链接多个命令，用法和unix下的管道类似：|前面的命令将运算结果(或返回值)传递给后一个命令的最后一个位置。

例如：

{{.}} | printf "%s\n" "abcd" 

{{.}}的结果将传递给printf，且传递的参数位置是"abcd"之后。

命令可以有超过1个的返回值，这时第二个返回值必须为err类型。

需要注意的是，并非只有使用了|才是pipeline。Go template中，pipeline的概念是传递数据，只要能产生数据的，都是pipeline。这使得某些操作可以作为另一些操作内部的表达式先运行得到结果，就像是Unix下的命令替换一样。

例如，下面的(len "output")是pipeline，它整体先运行。

{{println (len "output")}} 

下面是Pipeline的几种示例，它们都输出"output"：

{{`"output"`}} {{printf "%q" "output"}} {{"output" | printf "%q"}} {{printf "%q" (print "out" "put")}} {{"put" | printf "%s%s" "out" | printf "%q"}} {{"output" | printf "%s" | printf "%q"}} 

变量

可以在template中定义变量：

// 未定义过的变量 $var := pipeline // 已定义过的变量 $var = pipeline 

例如：

{{- $how_long :=(len "output")}} {{- println $how_long}} // 输出6 

再例如：

tx := template.Must(template.New("hh").Parse( `{{range $x := . -}} {{$y := 333}} {{- if (gt $x 33)}}{{println $x $y ($z := 444)}}{{- end}} {{- end}} `)) s := []int{11, 22, 33, 44, 55} _ = tx.Execute(os.Stdout, s) 

输出结果：

44 333 444 55 333 444 

上面的示例中，使用range迭代slice，每个元素都被赋值给变量$x，每次迭代过程中，都新设置一个变量$y，在内层嵌套的if结构中，可以使用这个两个外层的变量。在if的条件表达式中，使用了一个内置的比较函数gt，如果$x大于33，则为true。在println的参数中还定义了一个$z，之所以能定义，是因为($z := 444)的过程是一个Pipeline，可以先运行。

需要注意三点：

• 变量有作用域，只要出现end，则当前层次的作用域结束。内层可以访问外层变量，但外层不能访问内层变量。
• 有一个特殊变量$，它代表模板的最顶级作用域对象(通俗地理解，是以模板为全局作用域的全局变量)，在Execute()执行的时候进行赋值，且一直不变。例如上面的示例中，$ = [11 22 33 44 55]。再例如，define定义了一个模板t1，则t1中的$作用域只属于这个t1。
• 变量不可在模板之间继承。普通变量可能比较容易理解，但对于特殊变量"."和"$"，比较容易搞混。见下面的例子。

例如：

func main() { t1 := template.New("test1") tmpl, _ := t1.Parse( ` {{- define "T1"}}ONE {{println .}}{{end}} {{- define "T2"}}{{template "T1" $}}{{end}} {{- template "T2" . -}} `) _ = tmpl.Execute(os.Stdout, "hello world") } 

上面使用define额外定义了T1和T2两个模板，T2中嵌套了T1。{{template "T2" .}}的点代表顶级作用域的"hello world"对象。在T2中使用了特殊变量$，这个$的范围是T2的，不会继承顶级作用域"hello world"。但因为执行T2的时候，传递的是"."，所以这里的$的值仍然是"hello world"。

不仅$不会在模板之间继承，.也不会在模板之间继承(其它所有变量都不会继承)。实际上，template可以看作是一个函数，它的执行过程是template("T2",.)。如果把上面的$换成"."，结果是一样的。如果换成{{template "T2"}}，则$=nil

如果看不懂这些，后文有解释。

条件判断

有以下几种if条件判断语句，其中第三和第四是等价的。

{{if pipeline}} T1 {{end}} {{if pipeline}} T1 {{else}} T0 {{end}} {{if pipeline}} T1 {{else if pipeline}} T0 {{end}} {{if pipeline}} T1 {{else}}{{if pipeline}} T0 {{end}}{{end}} 

需要注意的是，pipeline为false的情况是各种数据对象的0值：数值0，指针或接口是nil，数组、slice、map或string则是len为0。

range...end迭代

有两种迭代表达式类型：

{{range pipeline}} T1 {{end}} {{range pipeline}} T1 {{else}} T0 {{end}} 

range可以迭代slice、数组、map或channel。迭代的时候，会设置"."为当前正在迭代的元素。

对于第一个表达式，当迭代对象的值为0值时，则range直接跳过，就像if一样。对于第二个表达式，则在迭代到0值时执行else语句。

tx := template.Must(template.New("hh").Parse( `{{range $x := . -}} {{println $x}} {{- end}} `)) s := []int{11, 22, 33, 44, 55} _ = tx.Execute(os.Stdout, s) 

需注意的是，range的参数部分是pipeline，所以在迭代的过程中是可以进行赋值的。但有两种赋值情况：

{{range $value := .}} {{range $key,$value := .}} 

如果range中只赋值给一个变量，则这个变量是当前正在迭代元素的值。如果赋值给两个变量，则第一个变量是索引值(map/slice是数值，map是key)，第二个变量是当前正在迭代元素的值。

下面是在html中使用range的一个示例。test.html文件内容如下：

 {{ range . }} 
{{ . }}
 {{ else }} 
 Nothing to show 
 {{ end}} 
提示：
                    本文由神整理自网络，如有侵权请联系本站删除！
                    

                    本站声明： 

                    1、本站所有资源均来源于互联网，不保证100%完整、不提供任何技术支持； 

                    2、本站所发布的文章以及附件仅限用于学习和研究目的;不得将用于商业或者非法用途；否则由此产生的法律后果，本站概不负责！
                

                

                

                                            
上一篇：go语言beego框架分页器操作及接口频率限制示例_Golang_
                                                                
下一篇：深入解析Go template模板使用详解_Golang_