Go template详解（上）- 注释、作用域、空格和空行、管道、{{range .}}、{{with .}}（helm进阶语法）

1. 注释 {{/* xxxx */}}

{{/* xxxx */}}
1

2. 作用域

2.1 顶级作用域 {{ . }}

• 代码

package main

import (
	"html/template"
	"os"
)

type Person struct {
	Name string
	Age  int64
}

func main() {
	p := Person{"GuanYu",25}
	tmpl := template.New("test")
	tmpl = template.Must(tmpl.Parse("Name: {{.Name}}, Age: {{.Age}}\nAll: {{.}}"))
	_ = tmpl.Execute(os.Stdout, p)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

• 输出

Name: GuanYu, Age: 25
All: {GuanYu 25}
1
2

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

• 另一种写法

模板换行我们也可以不写 \n，而用"反引号"代替"引号"

package main

import (
	"html/template"
	"os"
)

type Person struct {
	Name string
	Age  int64
}

func main() {
	p := Person{"GuanYu",25}
	tmpl := template.New("test")
	tmpl = template.Must(tmpl.Parse(`
Name: {{.Name}}
Age: {{.Age}} 
All {{ . }}
`))
	_ = tmpl.Execute(os.Stdout, p)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

结果显示

Name: GuanYu
Age: 25 
All {GuanYu 25}
1
2
3

2.2 相对作用域 {{range . }} xxxx {{end}}

{{range . }} xxxx {{end}}

• 完整代码

package main

import (
	"os"
	"text/template"
)

type Weapon struct {
	WeaponName string
	Attack int
}

type User struct {
	UserName string
	Weapons   []Weapon
	Wives  []string
}

func main() {
	t := template.New("test")
	t = template.Must(t.Parse(
		`姓名：{{.UserName}}
{{- range .Weapons }}
武器： {{.WeaponName}}
{{- end }}
{{- range .Wives  }}
妻子： {{ . }}
{{- end }}`))
	WeaponL := Weapon{WeaponName:"双股剑（雄）" }
	WeaponR := Weapon{WeaponName:"双股剑（雌）" }
	p := User{UserName: "刘备",
		Weapons:  []Weapon{WeaponL,WeaponR},
		Wives: []string{"甘夫人","糜夫人","孙尚香"}}
	t.Execute(os.Stdout, p)
}
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

• 输出

姓名：刘备
武器： 双股剑（雄）
武器： 双股剑（雌）
妻子： 甘夫人
妻子： 糜夫人
妻子： 孙尚香
1
2
3
4
5
6

说明：

• template开始时，顶级作用域在p，因此{{- range .Weapons }}可指向p.Weapons
• 而进入range循环后则进入一个p.Weapons内的相对域，因此{{.WeaponName}}指向了绝对位置p.Weapons.WeaponName
• 后边妻子的循环与此相同

2.3 切换作用域 {{with .xxx }} xxx {{end}}

• 代码

package main

import (
	"os"
	"text/template"
)

type Weapon struct {
	WeaponName string
	Attack int
}

type User struct {
	UserName string
	Weapons   []Weapon
	Wives  []string
}

func main() {
	t := template.New("test")
	t = template.Must(t.Parse(
		`姓名：{{.UserName}}
{{- with .Weapons }}
{{- range . }}
武器： {{.WeaponName}}
{{- end }}
{{- end }}
{{- range .Wives  }}
妻子： {{ . }}
{{- end }}`))
	WeaponL := Weapon{WeaponName:"双股剑（雄）" }
	WeaponR := Weapon{WeaponName:"双股剑（雌）" }
	p := User{UserName: "刘备",
		Weapons:  []Weapon{WeaponL,WeaponR},
		Wives: []string{"甘夫人","糜夫人","孙尚香"}}
	t.Execute(os.Stdout, p)
}
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

• 显示结果

姓名：刘备
武器： 双股剑（雄）
武器： 双股剑（雌）
妻子： 甘夫人
妻子： 糜夫人
妻子： 孙尚香
1
2
3
4
5
6

说明：

• template开始时，顶级作用域在p
• 而{{ with .Weapons }}开始到第二个{{- end }}之间，顶级作用域切换到p..Weapons
  因此其中的 {{- range . }} 则在p.Weapons中循环（而不是p）
• 到切换作用域结束后（第二个{{- end }}），依然使用{{- range .Wives }} 指到p..Wives

3. 去空格和去空行 {{- xxx}}

3.1 去空行

• 之前“1.2”中的例子中我们可以看见很多-，比如{{- range . }}，{{- end }}，这些是为了消除空行，其输出如下：

姓名：刘备
武器： 双股剑（雄）
武器： 双股剑（雌）
妻子： 甘夫人
妻子： 糜夫人
妻子： 孙尚香
1
2
3
4
5
6

• {{- range . }}和{{range . }}

如果我们将第一个range修改为{{range . }}

	t = template.Must(t.Parse(
		`姓名：{{.UserName}}
{{- with .Weapons }}
{{range . }}
武器： {{.WeaponName}}
{{- end }}
{{- end }}
{{- range .Wives  }}
妻子： {{ . }}
{{- end }}`))
1
2
3
4
5
6
7
8
9
10

则输出如下：

姓名：刘备

武器： 双股剑（雄）
武器： 双股剑（雌）
妻子： 甘夫人
妻子： 糜夫人
妻子： 孙尚香
1
2
3
4
5
6
7

我们可以看到，在第一个range的位置出现了一个空行。

• {{- end}}和{{end }}
  如果我们将第一个end处改为{{end }}

	t = template.Must(t.Parse(
		`姓名：{{.UserName}}
{{- with .Weapons }}
{{range . }}
武器： {{.WeaponName}}
{{end }}
{{- end }}
{{- range .Wives  }}
妻子： {{ . }}
{{- end }}`))
1
2
3
4
5
6
7
8
9
10

• 则输出如下：

姓名：刘备

武器： 双股剑（雄）

武器： 双股剑（雌）

妻子： 甘夫人
妻子： 糜夫人
妻子： 孙尚香
1
2
3
4
5
6
7
8
9

可见，每次循环读取都会因end产生一个空行。

3.2 去空格

• 我们在妻子和值之间加很多空格妻子： {{ . }}：

package main

import (
	"os"
	"text/template"
)

type Weapon struct {
	WeaponName string
	Attack int
}

type User struct {
	UserName string
	Weapons   []Weapon
	Wives  []string
}

func main() {
	t := template.New("test")
	t = template.Must(t.Parse(
		`姓名：{{.UserName}}
{{- with .Weapons }}
{{range . }}
武器： {{.WeaponName}}
{{- end }}
{{- end }}
{{- range .Wives  }}
妻子：       {{ . }}
{{- end }}`))
	WeaponL := Weapon{WeaponName:"双股剑（雄）" }
	WeaponR := Weapon{WeaponName:"双股剑（雌）" }
	p := User{UserName: "刘备",
		Weapons:  []Weapon{WeaponL,WeaponR},
		Wives: []string{"甘夫人","糜夫人","孙尚香"}}
	t.Execute(os.Stdout, p)
}
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

则结果如下：

姓名：刘备

武器： 双股剑（雄）
武器： 双股剑（雌）
妻子：       甘夫人
妻子：       糜夫人
妻子：       孙尚香
1
2
3
4
5
6
7

• 现在我们去掉这些空格，以上代码修改如下：

修改为妻子： {{- . }}

	t = template.Must(t.Parse(
		`姓名：{{.UserName}}
{{- with .Weapons }}
{{range . }}
武器： {{.WeaponName}}
{{- end }}
{{- end }}
{{- range .Wives  }}
妻子：       {{- . }}
{{- end }}`))
1
2
3
4
5
6
7
8
9
10

则结果为：

姓名：刘备

武器： 双股剑（雄）
武器： 双股剑（雌）
妻子：甘夫人
妻子：糜夫人
妻子：孙尚香
1
2
3
4
5
6
7

如果是{{ xxxx }}后边有空格，则将-写在右侧{{ xxxx -}}

4. 管道 {{ | }}

将前边的结果传给后边最后一个位置

• 代码

package main

import (
	"os"
	"text/template"
)

func main() {
	t := template.New("xiShu")
	t = template.Must(t.Parse(
`{{printf "%q" "关羽"}}
{{"关羽" | printf "%q"}}
{{"关羽" | printf "%q" | printf "%q"}}`))
	p := ""
	t.Execute(os.Stdout, p)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

• 结果

"关羽"
"关羽"
"\"关羽\""
1
2
3

说明：

• 第一个正常打印关羽
• 第二个将关羽通过管道符传到后边的最后一个位置
• 第三个，有两个管道符，依次处理，因此加了两层引号（%q是带引号打印，处理一次加一层）

---