快速开始

  1. func handler(w http.ResponseWriter,r *http.Request){
  2.         t := template.New("new template") //创建一个模板
  3.         t,err := t.ParseFile("tpl/welcome.html",nil) //解析模板文件
  4.         if err != nil{            panic(err.Error())
  5.         }
  6.         user := GetUser() //获取用户信息
  7.         t.Execute(w,user)    //执行模板，并通过w输出
  8.     }

各种模板

  • {{.}}表示当前对象，如user对象

  • {{.FieldName}}表示对象的某个字段

  • {{range …}}{{end}} go中for…range语法类似，循环

  • {{with …}}{{end}} 当前对象的值，上下文

  1. //一个模板文件例子
  2.     hello {{.UserName}}!
  3.     {{range .Emails}}
  4.         an email {{.}}
  5.     {{end}}
  6.     {{with .Friends}}
  7.         {{range .}}
  8.             my friend name is {{.Fname}}
  9.         {{end}}
  10.     {{end}}

{{if …}}{{else}}{{end}} go中的if-else语法类似，条件选择

  1. //if 后只能出现bool值，不支持bool表达式    
  2.  if-else demo:
  3.     {{if .ShowFlag}}
  4.         section if    {{else}}
  5.         section else.
  6.     {{end}}
  7. pipeline

左边的输出作为右边的输入

  1. //当前对象作为参数，传入内置函数html中
  2.     {{. | html}}

模板变量

模板使用过程中定义局部变量

  1.  {{with $x := "output"}}{{$x}}{{end}}
  2.     {{with $x := "output"}}{{$x | printf "%s"}}{{end}}

输出

  1. outputoutput

模板函数

支持的函数类型

  1. func(args ...interface{})string

函数定义例子

  1. func Say(args ...interface{})string{        
  2.     return fmt.Sprintf("%s %v","Hello",args[0])
  3.  }

注册函数

  1. t = t.Funcs(template.FuncMap{"Say":Say})

模版定义

  1. {{Say `Func`}}
  2.     {{`Pipe` | Say}}

输出：

  1. Hello FuncHello Pipe

template中内置函数

  1. var builtins = FuncMap{        
  2.  "and":      and,        
  3.  "call":     call,        
  4.  "html":     HTMLEscaper,        
  5.  "index":    index,        
  6.  "js":       JSEscaper,        
  7.  "len":      length,        
  8.  "not":      not,        
  9.  "or":       or,        
  10.  "print":    fmt.Sprint,        
  11.  "printf":   fmt.Sprintf,        
  12.  "println":  fmt.Sprintln,        
  13.  "urlquery": URLQueryEscaper,
  14.     }

Must操作

检测模板是否正确：大括号是否匹配，注释是否正确关闭，变量是否正确

  1. tOk := template.New("first")        
  2.         template.Must(tOk.Parse(" some static text /* and a comment */"))
  3.         fmt.Println("The first one parsed OK.")        
  4.         template.Must(template.New("second").Parse("some static text {{ .Name }}"))
  5.         fmt.Println("The second one parsed OK.")
  7.         fmt.Println("The next one ought to fail.")
  8.         tErr := template.New("check parse error with Must")        
  9.         template.Must(tErr.Parse(" some static text {{ .Name }"))

输出

  1. The first one parsed OK.
  2.     The second one parsed OK.
  3.     The next one ought to fail.
  4.     panic: template: check parse error with Must:1: unexpected "}" in command

模板嵌套

将模版模块化，如在web开发中定义header，content，footer三个子模块

  1. //声明
  2.     {{define "module_name"}}content{{end}}
  3.     //调用
  4.     {{template "module_name"}}

以下定义三个文件：

  • header.html
  1. {{define "header"}}
  2.     <html>
  3.     <head>
  4.         <title>演示信息</title>
  5.     </head>
  6.     <body>
  7.     {{end}}
  • footer.tmpl
  1. {{define "footer"}}
  2.     </body>
  3.     </html>
  4.     {{end}}
  • content.tmpl
  1. {{define "content"}}
  2.     {{template "header"}}
  3.      <h1>演示嵌套</h1>
  4.     <ul>
  5.         <li>嵌套使用define定义子模板</li>
  6.         <li>调用使用template</li>
  7.     </ul>
  8.     {{template "footer"}}
  9.     {{end}}

go代码

ParseFiles：所有嵌套的模版全部都解析到模板中

  1. s1,_ := template.ParseFiles("header.tmpl","content.tmpl","footer.tmpl")
  2. s1.ExecuteTemplate(w, "header",nil)
  3. s1.ExecuteTemplate(w, "footer", nil)
  4. s1.ExecuteTemplate(w, "content", nil)
  5. cle/details/79384394

golang Template - 图1