template.md

import "text/template"

type Inventory struct {
    Material string
    Count    uint
}
 
sweaters := Inventory{"wool", 17}
tmpl, err := template.New("test").Parse("{{.Count}} items are made of {{.Material}}")
if err != nil { panic(err) }
err = tmpl.Execute(os.Stdout, sweaters)
if err != nil { panic(err) }

"{{23 -}} < {{- 45}}"
// 生成的输出
"23<45"

{{/* 这是注释内容 */}}

{{$name := "Alice"}}
{{$age := 18}}
{{$round2 := true}}
Name: {{$name}}
Age: {{$age}}
Round2: {{$round2}}
 
// 输出
Name: Alice
Age: 18
Round2: true

{{if .yIsZero}}
        除数不能为 0
{{else}}
        {{.result}}
{{end}}

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

{{range $name := .Names}}
        {{$name}}
{{end}}
 
// 输出
Alice
Bob
Carol
David
 
{{range $i, $name := .Names}}
        {{$i}}. {{$name}}
{{end}}
 
// 输出
0. Alice
1. Bob
2. Carol
3. David

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

// 不带with
SKU: {{.Inventory.SKU}}
Name: {{.Inventory.Name}}
UnitPrice: {{.Inventory.UnitPrice}}
Quantity: {{.Inventory.Quantity}}
 
// 带with
{{with .Inventory}}
        SKU: {{.SKU}}
        Name: {{.Name}}
        UnitPrice: {{.UnitPrice}}
        Quantity: {{.Quantity}}
{{end}}

{{with pipeline}} T1 {{end}}
{{with pipeline}} T1 {{else}} T0 {{end}}

{{$name1 := "alice"}}
name1: {{$name1}}
{{with true}}
        {{$name1 = "alice2"}}
        {{$name2 := "bob"}}
        name2: {{$name2}}
{{end}}
name1 after with: {{$name1}}
 
 
// 输出
name1: alice
name2: bob
name1 after with: alice2

{$name1 := "alice"}}
name1: {{$name1}}
{{with true}}
        {{$name1 := "alice2"}}
        {{$name2 := "bob"}}
        name1 in with: {{$name1}}
        name2: {{$name2}}
{{end}}
name1 after with: {{$name1}}
 
// 输出
name1: alice
name1 in with: alice2
name2: bob
name1 after with: alice

tmpl := template.New("test").Funcs(template.FuncMap{
        "add": func(a, b int) int {
        return a + b
        },
})
 
_, err := tmpl.Parse(`
result: {{add 1 2}}
`)
 
// 输出
result: 3

and
// 通过返回第一个空的参数或最后一个参数，来返回参数的逻辑与的结果
// 即，“and x y”的行为类似于“ if x then y else x”。 对所有参数进行求值。
call
// 返回调用第一个参数的结果，该参数必须是一个函数，其余参数作为它的参数。
// 因此，“call X.Y 1 2”在Go表示法中是 .X.Y(1,2)，其中Y是函数值字段，map条目等。
// 第一个参数必须是产生函数类型值的评估结果（不同于诸如print之类的预定义函数）。
// 该函数必须返回一个或两个结果值，其中第二个是error类型。
// 如果参数不匹配该函数，或者返回的错误值为非nil，则执行停止。
html
// 返回与其参数的文本表示形式等效的转义HTML。
// 此功能在html/template中不可用，但有一些例外。
index
// 返回通过后续参数索引其第一个参数的结果。
//  因此，按照Go语法中：
// “index x 1 2 3”是x [1] [2] [3]
//  每个索引项目必须是map，切片或数组
slice
// slice返回将其第一个参数与其余参数相切片的结果。
// 因此，按照Go语法：
// “ slice x 1 2”是x [1:2]
// “ slice x”是x [:]
// “ slice x 1”是x [1:]
// “ slice x 1 2 3” “是x [1:2:3]
// 第一个参数必须是字符串，切片或数组。
js      // 返回等效于其参数的文本表示形式的转义JavaScript。
len     // 返回其参数的整数长度。
not     // 返回其单个参数的逻辑反。
or
// 通过返回第一个非空参数或最后一个参数，来返回其参数的逻辑或的结果，
// 即“or x y”的行为类似于“if x then x else y”。 对所有参数进行求值。
print   // fmt.Sprint的别名
printf  // fmt.Sprintf的别名
println //  fmt.Sprintln的别名
urlquery
// 以适合嵌入URL查询的形式返回其参数的文本表示形式的转义值。
// 此功能在html/template中不可用，但有一些例外。

{{$name1 := "alice"}}
{{$name2 := "bob"}}
{{$age1 := 18}}
{{$age2 := 23}}
 
{{if eq $age1 $age2}}
        年龄相同
{{else}}
        年龄不相同
{{end}}
 
{{if ne $name1 $name2}}
        名字不相同
{{end}}
 
{{if gt $age1 $age2}}
        alice 年龄比较大
{{else}}
        bob 年龄比较大
{{end}}
 
// 输出
年龄不相同
名字不相同
bob 年龄比较大

result: {{add 1 3 | add 2 | add 2}}
 
// 输出
result: 8

tmpl := template.New("test").Funcs(template.FuncMap{
        "join": strings.Join,
})
 
{{define "list"}}
    {{join . ", "}}
{{end}}
Names: {{template "list" .names}}
 
// 输出
Names: Alice, Bob, Cindy, David

tmpl, err := template.ParseFiles("template_local.tmpl")

{{range .names}}
    - {{.}}
{{end}}

err = tmpl.ExecuteTemplate(w, "template_local.tmpl", map[string]interface{}{
        "names": []string{"Alice", "Bob", "Cindy", "David"},
})

func HTMLEscape(w io.Writer, b []byte)

func HTMLEscapeString(s string) string

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

func IsTrue(val interface{}) (truth, ok bool)

func JSEscape(w io.Writer, b []byte)

func JSEscapeString(s string) string

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

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

type ExecError struct {
    Name string // Name of template.
    Err  error  // Pre-formatted error.
}

func (e ExecError) Error() string

func (e ExecError) Unwrap() error

type FuncMap map[string]interface{}

type Template struct {
        name string
        *parse.Tree
        *common
        leftDelim  string
        rightDelim string
}

// 定义一个模板
const letter = `
Dear {{.Name}},
{{if .Attended}}
It was a pleasure to see you at the wedding.
{{- else}}
It is a shame you couldn't make it to the wedding.
{{- end}}
{{with .Gift -}}
Thank you for the lovely {{.}}.
{{end}}
Best wishes,
Josie
`
 
// 准备一些数据以插入模板
type Recipient struct {
    Name, Gift string
    Attended   bool
}
var recipients = []Recipient{
    {"Aunt Mildred", "bone china tea set", true},
    {"Uncle John", "moleskin pants", false},
    {"Cousin Rodney", "", false},
}
 
// 创建一个template对象并将常量letter解析给它
t := template.Must(template.New("letter").Parse(letter))
 
// 对每一个recipient执行模板
for _, r := range recipients {
    err := t.Execute(os.Stdout, r)
    if err != nil {
        log.Println("executing template:", err)
    }
}
 
// 输出
Dear Aunt Mildred,
 
It was a pleasure to see you at the wedding.
Thank you for the lovely bone china tea set.
 
Best wishes,
Josie
 
Dear Uncle John,
 
It is a shame you couldn't make it to the wedding.
Thank you for the lovely moleskin pants.
 
Best wishes,
Josie
 
Dear Cousin Rodney,
 
It is a shame you couldn't make it to the wedding.
 
Best wishes,
Josie

const (
    master  = `Names:{{block "list" .}}{{"\n"}}{{range .}}{{println "-" .}}{{end}}{{end}}`
    overlay = `{{define "list"}} {{join . ", "}}{{end}} `
)
var (
    funcs     = template.FuncMap{"join": strings.Join}
    guardians = []string{"Gamora", "Groot", "Nebula", "Rocket", "Star-Lord"}
)
masterTmpl, err := template.New("master").Funcs(funcs).Parse(master)
if err != nil {
    log.Fatal(err)
}
overlayTmpl, err := template.Must(masterTmpl.Clone()).Parse(overlay)
if err != nil {
    log.Fatal(err)
}
if err := masterTmpl.Execute(os.Stdout, guardians); err != nil {
    log.Fatal(err)
}
if err := overlayTmpl.Execute(os.Stdout, guardians); err != nil {
    log.Fatal(err)
}
 
// 输出
Names:
- Gamora
- Groot
- Nebula
- Rocket
- Star-Lord
Names: Gamora, Groot, Nebula, Rocket, Star-Lord

// 首先，创建一个FuncMap用来注册函数
funcMap := template.FuncMap{
        // “title”是在模板文本中将调用的函数
    "title": strings.Title,
}
 
// 一个简单的模板定义来测试函数
// 通过几种方式打印输入文本：
// - 原版输出
// - 调用title函数
// - 调用title函数然后以%q输出
// - 以%q输出然后调用title函数
const templateText = `
Input: {{printf "%q" .}}
Output 0: {{title .}}
Output 1: {{title . | printf "%q"}}
Output 2: {{printf "%q" . | title}}
`
 
// 创建一个模板，然后添加函数，并解析文本
tmpl, err := template.New("titleTest").Funcs(funcMap).Parse(templateText)
if err != nil {
    log.Fatalf("parsing: %s", err)
}
 
// 运行模板来验证输出
err = tmpl.Execute(os.Stdout, "the go programming language")
if err != nil {
    log.Fatalf("execution: %s", err)
}
 
// 输出
Input: "the go programming language"
Output 0: The Go Programming Language
Output 1: "The Go Programming Language"
Output 2: "The Go Programming Language"

// 创建一个临时目录并使用示例模板定义填充该目录
// 通常，模板文件将已经存在与程序已知的某个位置
dir := createTestDir([]templateFile{
    // T0.tmpl 是一个纯模板文件仅调用T1
    {"T0.tmpl", `T0 invokes T1: ({{template "T1"}})`},
    // T1.tmpl 定义一个模板, T1 调用 T2
    {"T1.tmpl", `{{define "T1"}}T1 invokes T2: ({{template "T2"}}){{end}}`},
    // T2.tmpl 定义一个模板 T2.
    {"T2.tmpl", `{{define "T2"}}This is T2{{end}}`},
})
// 测试后清除目录
defer os.RemoveAll(dir)
 
// pattern是用于查找所有模板文件的全局模式
pattern := filepath.Join(dir, "*.tmpl")
 
// T0.tmpl 是第一个匹配的名字 ，因此它成为起始模板即ParseGlob的返回值
tmpl := template.Must(template.ParseGlob(pattern))
 
err := tmpl.Execute(os.Stdout, nil)
if err != nil {
    log.Fatalf("template execution: %s", err)
}
 
// 输出
T0 invokes T1: (T1 invokes T2: (This is T2))

// 创建一个临时目录并使用示例模板定义填充该目录
// 通常，模板文件将已经存在与程序已知的某个位置
dir := createTestDir([]templateFile{
    // T1.tmpl定义一个模板, T1 调用 T2.
    {"T1.tmpl", `{{define "T1"}}T1 invokes T2: ({{template "T2"}}){{end}}`},
    // T2.tmpl 定义模板 T2.
    {"T2.tmpl", `{{define "T2"}}This is T2{{end}}`},
})
// 测试后清除目录
defer os.RemoveAll(dir)
 
// pattern是用于查找所有模板文件的全局模式
pattern := filepath.Join(dir, "*.tmpl")
 
// 加载帮助程序
templates := template.Must(template.ParseGlob(pattern))
// 添加一个驱动程序模板；用一个明确的模板定义来做到这一点
_, err := templates.Parse("{{define `driver1`}}Driver 1 calls T1: ({{template `T1`}})\n{{end}}")
if err != nil {
    log.Fatal("parsing driver1: ", err)
}
// 添加另一个驱动程序模板
_, err = templates.Parse("{{define `driver2`}}Driver 2 calls T2: ({{template `T2`}})\n{{end}}")
if err != nil {
    log.Fatal("parsing driver2: ", err)
}
 
// 在执行之前加载所有模板，text/template包不需要这种操作
// 但是html/template包的转义需要这样的操作，这是一个好习惯
err = templates.ExecuteTemplate(os.Stdout, "driver1", nil)
if err != nil {
    log.Fatalf("driver1 execution: %s", err)
}
err = templates.ExecuteTemplate(os.Stdout, "driver2", nil)
if err != nil {
    log.Fatalf("driver2 execution: %s", err)
}
 
// 输出
Driver 1 calls T1: (T1 invokes T2: (This is T2))
Driver 2 calls T2: (This is T2)

// 创建一个临时目录并使用示例模板定义填充该目录
// 通常，模板文件将已经存在与程序已知的某个位置
dir := createTestDir([]templateFile{
    // T0.tmpl 是一个纯模板文件仅调用 T1.
    {"T0.tmpl", "T0 ({{.}} version) invokes T1: ({{template `T1`}})\n"},
    // T1.tmpl 定义一个模板, T1 调用 T2. 注意 T2 并没有定义
    {"T1.tmpl", `{{define "T1"}}T1 invokes T2: ({{template "T2"}}){{end}}`},
})
// 测试后清空目录
defer os.RemoveAll(dir)
 
// pattern是用于查找所有模板文件的全局模式
pattern := filepath.Join(dir, "*.tmpl")
 
// 加载驱动程序
drivers := template.Must(template.ParseGlob(pattern))
 
//  必须定义T2模板的实现，首先克隆驱动程序，然后将T2的定义添加到模板名称空间
// 1. 克隆帮助程序集，以创建一个新的名称空间来运行它们
first, err := drivers.Clone()
if err != nil {
    log.Fatal("cloning helpers: ", err)
}
// 2. 定义 T2, version A, 并解析它
_, err = first.Parse("{{define `T2`}}T2, version A{{end}}")
if err != nil {
    log.Fatal("parsing T2: ", err)
}
 
// 使用不同版本的T2重复上述过程
// 1. 克隆驱动程序
second, err := drivers.Clone()
if err != nil {
    log.Fatal("cloning drivers: ", err)
}
// 2. 定义 T2, version B, 并解析它
_, err = second.Parse("{{define `T2`}}T2, version B{{end}}")
if err != nil {
    log.Fatal("parsing T2: ", err)
}
 
// 以相反的顺序执行模板，以验证第一个模板不受第二个模板的影响。
err = second.ExecuteTemplate(os.Stdout, "T0.tmpl", "second")
if err != nil {
    log.Fatalf("second execution: %s", err)
}
err = first.ExecuteTemplate(os.Stdout, "T0.tmpl", "first")
if err != nil {
    log.Fatalf("first: execution: %s", err)
}
Output:
 
T0 (second version) invokes T1: (T1 invokes T2: (T2, version B))
T0 (first version) invokes T1: (T1 invokes T2: (T2, version A))

func Must(t *Template, err error) *Template

var t = template.Must(template.New("name").Parse("text"))

func New(name string) *Template

func ParseFiles(filenames ...string) (*Template, error)

func ParseGlob(pattern string) (*Template, error)

func (t *Template) AddParseTree(name string, tree *parse.Tree) (*Template, error)

func (t *Template) Clone() (*Template, error)

func (t *Template) DefinedTemplates() string

func (t *Template) Delims(left, right string) *Template

func (t *Template) Execute(wr io.Writer, data interface{}) error

func (t *Template) ExecuteTemplate(wr io.Writer, name string, data interface{}) error

func (t *Template) Funcs(funcMap FuncMap) *Template

func (t *Template) Lookup(name string) *Template

func (t *Template) Name() string

func (t *Template) New(name string) *Template

func (t *Template) Option(opt ...string) *Template

"missingkey=default" or "missingkey=invalid"
        // default的行为：什么也不做继续执行
        // 如果输出，索引操作的值是"<no value>"字符串
"missingkey=zero"
        // 该操作返回Map类型元素的零值
"missingkey=error"
        // 执行立即停止并返回错误

func (t *Template) Parse(text string) (*Template, error)

func (t *Template) ParseFiles(filenames ...string) (*Template, error)

func (t *Template) ParseGlob(pattern string) (*Template, error)

func (t *Template) Templates() []*Template