本文只關(guān)注Go text/template的底層結(jié)構(gòu)，帶上了很詳細(xì)的圖片以及示例幫助理解，有些地方也附帶上了源碼進(jìn)行解釋。有了本文的解釋，對于Go template的語法以及html/template的用法，一切都很簡單。

關(guān)于template的語法以及具體使用方法，見：Go template用法詳解

入門示例

package main

import (
	"html/template"
	"os"
)

type Person struct {
	Name string
	Age    int
}

func main() {
	p := Person{"longshuai", 23}
	tmpl, err := template.New("test").Parse("Name: {{.Name}}, Age: {{.Age}}")
	if err != nil {
		panic(err)
	}
	err = tmpl.Execute(os.Stdout, p)
	if err != nil {
		panic(err)
	}
	fmt.Println(tmpl)
}

上面定義了一個Person結(jié)構(gòu)，有兩個大寫字母開頭(意味著這倆字段是導(dǎo)出的)的字段Name和Age。然后main()中創(chuàng)建了Person的實例對象p。

緊接著使用template.New()函數(shù)創(chuàng)建了一個空Template實例(對象)，然后通過這個template實例調(diào)用Parse()方法，Parse()方法用來解析、評估模板中需要執(zhí)行的action，其中需要評估的部分都使用{{}}包圍，并將評估后(解析后)的結(jié)果賦值給tmpl。

最后調(diào)用Execute()方法，該方法將數(shù)據(jù)對象Person的實例p應(yīng)用到已經(jīng)解析的tmpl模板，最后將整個應(yīng)用合并后的結(jié)果輸出到os.Stdout。

上面的示例很簡單，兩個注意點：

• 流程：構(gòu)建模板對象New()-->解析數(shù)據(jù)Parse()-->應(yīng)用合并Execute()
• Parse()解析的對象中包含了{{}}，其中使用了點(.)，{{.Name}}代表Execute()第二個參數(shù)p對象的Name字段，同理{{.Age}}

也就是說，{{.}}代表的是要應(yīng)用的對象，類似于java/c++中的this，python/perl中的self。

更通用地，{{.}}表示的是所處作用域的當(dāng)前對象，而不僅僅只代表Execute()中的第二個參數(shù)對象。例如，本示例中{{.}}代表頂級作用域的對象p，如果Parse()中還有嵌套的作用域range，則{{.}}代表range迭代到的每個元素對象。如果了解perl語言，{{.}}可以理解為默認(rèn)變量$_。

模板關(guān)聯(lián)(associate)

template中有不少函數(shù)、方法都直接返回*Template類型。

上圖中使用紅色框線框起來一部分返回值是*Template的函數(shù)、方法。對于函數(shù)，它們返回一個Template實例(假設(shè)為t)，對于使用t作為參數(shù)的Must()函數(shù)和那些框起來的Template方法，它們返回的*Template其實是原始實例t。

例如：

t := template.New("abc")
tt,err := t.Parse("xxxxxxxxxxx")

這里的t和tt其實都指向同一個模板對象。

這里的t稱為模板的關(guān)聯(lián)名稱。通俗一點，就是創(chuàng)建了一個模板，關(guān)聯(lián)到變量t上。但注意，t不是模板的名稱，因為Template中有一個未導(dǎo)出的name字段，它才是模板的名稱?？梢酝ㄟ^Name()方法返回name字段的值，而且仔細(xì)觀察上面的函數(shù)、方法，有些是以name作為參數(shù)的。

之所以要區(qū)分模板的關(guān)聯(lián)名稱(t)和模板的名稱(name)，是因為一個關(guān)聯(lián)名稱t(即模板對象)上可以"包含"多個name，也就是多個模板，通過t和各自的name，可以調(diào)用到指定的模板。

模板結(jié)構(gòu)詳解

首先看Template結(jié)構(gòu)：

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

name是這個Template的名稱，Tree是解析樹，common是另一個結(jié)構(gòu)，稍后解釋。leftDelim和rightDelim是左右兩邊的分隔符，默認(rèn)為{{和}}。

這里主要關(guān)注name和common兩個字段，name字段沒什么解釋的。common是一個結(jié)構(gòu)：

type common struct {
	tmpl   map[string]*Template // Map from name to defined templates.
	option option
	muFuncs    sync.RWMutex // protects parseFuncs and execFuncs
	parseFuncs FuncMap
	execFuncs  map[string]reflect.Value
}

這個結(jié)構(gòu)的第一個字段tmpl是一個Template的map結(jié)構(gòu)，key為template的name，value為Template。也就是說，一個common結(jié)構(gòu)中可以包含多個Template，而Template結(jié)構(gòu)中又指向了一個common結(jié)構(gòu)。所以，common是一個模板組，在這個模板組中的(tmpl字段)所有Template都共享一個common(模板組)，模板組中包含parseFuncs和execFuncs。

大概結(jié)構(gòu)如下圖：

除了需要關(guān)注的name和common，parseFuncs和execFuncs這兩個字段也需要了解下，它們共同成為模板的FuncMap。

New()函數(shù)和init()方法

使用template.New()函數(shù)可以創(chuàng)建一個空的、無解析數(shù)據(jù)的模板，同時還會創(chuàng)建一個common，也就是模板組。

func New(name string) *Template {
	t := &Template{
		name: name,
	}
	t.init()
	return t
}

其中t為模板的關(guān)聯(lián)名稱，name為模板的名稱，t.init()表示如果模板對象t還沒有common結(jié)構(gòu)，就構(gòu)造一個新的common組：

func (t *Template) init() {
	if t.common == nil {
		c := new(common)
		c.tmpl = make(map[string]*Template)
		c.parseFuncs = make(FuncMap)
		c.execFuncs = make(map[string]reflect.Value)
		t.common = c
	}
}

也就是說，template.New()函數(shù)不僅創(chuàng)建了一個模板，還創(chuàng)建了一個空的common結(jié)構(gòu)(模板組)。需要注意，新創(chuàng)建的common是空的，只有進(jìn)行模板解析(Parse()，ParseFiles()等操作)之后，才會將模板添加到common的tmpl字段(map結(jié)構(gòu))中。

所以，下面的代碼：

tmpl := template.New("mytmpl1")

執(zhí)行完后將生成如下結(jié)構(gòu)，其中tmpl為模板關(guān)聯(lián)名稱，mytmpl1為模板名稱。

因為還沒有進(jìn)行解析操作，所以上圖使用虛線表示尚不存在的部分。

實際上，在template包中，很多涉及到操作Template的函數(shù)、方法，都會調(diào)用init()方法保證返回的Template都有一個有效的common結(jié)構(gòu)。當(dāng)然，因為init()方法中進(jìn)行了判斷，對于已存在common的模板，不會新建common結(jié)構(gòu)。

假設(shè)現(xiàn)在執(zhí)行了Parse()方法，將會把模板name添加到common tmpl字段的map結(jié)構(gòu)中，其中模板name為map的key，模板為map的value。

例如：

func main() {
	t1 := template.New("test1")
	tmpl,_ := t1.Parse(
			`{{define "T1"}}ONE{{end}}
			{{define "T2"}}TWO{{end}}
			{{define "T3"}}{{template "T1"}} {{template "T2"}}{{end}}
			{{template "T3"}}`)
	fmt.Println(t1)
	fmt.Println(tmpl)
	fmt.Println(t1.Lookup("test1"))  // 使用關(guān)聯(lián)名稱t1檢索test1模板
	fmt.Println(t1.Lookup("T1"))
	fmt.Println(tmpl.Lookup("T2")) // 使用關(guān)聯(lián)名稱tmpl檢索T2模板
	fmt.Println(tmpl.Lookup("T3"))
}

上述代碼的執(zhí)行結(jié)果：注意前3行的結(jié)果完全一致，所有行的第二個地址完全相同。

&{test1 0xc0420a6000 0xc0420640c0  }
&{test1 0xc0420a6000 0xc0420640c0  }
&{test1 0xc0420a6000 0xc0420640c0  }
&{T1 0xc0420a6100 0xc0420640c0  }
&{T2 0xc0420a6200 0xc0420640c0  }
&{T3 0xc0420a6300 0xc0420640c0  }

首先使用template.New()函數(shù)創(chuàng)建了一個名為test1的模板，同時創(chuàng)建了一個模板組(common)，它們關(guān)聯(lián)在t1變量上。

然后調(diào)用Parse()方法，在Parse()的待解析字符串中使用define又定義了3個新的模板對象，模板的name分別為T1、T2和T3，其中T1和T2嵌套在T3中，因為調(diào)用的是t1的Parse()，所以這3個新創(chuàng)建的模板都會關(guān)聯(lián)到t1上。

也就是說，現(xiàn)在t1上關(guān)聯(lián)了4個模板：test1、T1、T2、T3，它們?nèi)脊蚕硗粋€common。因為已經(jīng)執(zhí)行了Parse()解析操作，這個Parse()會將test1、T1、T2、T3的name添加到common.tmpl的map中。也就是說，common的tmpl字段的map結(jié)構(gòu)中有4個元素。

結(jié)構(gòu)如下圖：

必須注意，雖然test1、T1、T2、T3都關(guān)聯(lián)在t1上，但t1只能代表test1(所以上圖中只有test1下面標(biāo)注了t1)，因為t1是一個Template類型?？梢哉J(rèn)為test1、T1、T2、T3這4個模板共享一個組，但T1、T2、T3都是對外部不可見的，只能通過特殊方法的查詢找到它們。

另外，前文說過，template包中很多返回*Template的函數(shù)、方法返回的其實是原始的t(看源代碼即可知道)，這個規(guī)則也適用于這里的Parse()方法，所以tmpl和t1這兩個變量是完全等價的，都指向同一個template，即test1。所以前面的執(zhí)行結(jié)果中前3行完全一致。

再回頭看上面代碼的執(zhí)行結(jié)果，假設(shè)結(jié)果中的每一行都分為3列，第一列為template name，第二個字段為parseTree的地址，第三列為common結(jié)構(gòu)的地址。因為tmpl1、t1都指向test1模板，所以前3行結(jié)果完全一致。因為test1、T1、T2、T3共享同一個common，所以第三列全都相同。因為每個模板的解析樹不一樣，所以第二列全都不一樣。

New()方法

除了template.New()函數(shù)，還有一個Template.New()方法：

// New allocates a new, undefined template associated with the given one and with the same
// delimiters. The association, which is transitive, allows one template to
// invoke another with a {{template}} action.
func (t *Template) New(name string) *Template {
	t.init()
	nt := &Template{
		name:       name,
		common:     t.common,
		leftDelim:  t.leftDelim,
		rightDelim: t.rightDelim,
	}
	return nt
}

看注釋很難理解，但是看它的代碼，結(jié)合前文的解釋，New()方法的作用很明顯。

首先t.init()保證有一個有效的common結(jié)構(gòu)，然后構(gòu)造一個新的Template對象nt，這個nt除了name和解析樹parse.Tree字段之外，其它所有內(nèi)容都和t完全一致。換句話說，nt和t共享了common。

也就是說，New()方法使得名為name的nt模板對象加入到了關(guān)聯(lián)組中。更通俗一點，通過調(diào)用t.New()方法，可以創(chuàng)建一個新的名為name的模板對象，并將此對象加入到t模板組中。

這和New()函數(shù)的作用基本是一致的，只不過New()函數(shù)是構(gòu)建新的模板對象并構(gòu)建一個新的common結(jié)構(gòu)，而New()方法則是構(gòu)建一個新的模板對象，并加入到已有的common結(jié)構(gòu)中。

只是還是要說明，因為New()出來的新對象在執(zhí)行解析之前(如Parse())，它們暫時都還不會加入到common組中，在New()出來之后，僅僅只是讓它指向已有的一個common結(jié)構(gòu)。

所以：

t1 := template.New("test1")
t1 = t1.Parse(...)
t2 := t1.New("test2")
t2 = t2.Parse(...)
t3 := t1.New("test3")

結(jié)構(gòu)圖：

如果t1和t2的Parse()中，都定義一個或多個name相同的模板會如何？例如：

t1 := template.New("test1")
t2 := t1.New("test2")
t1, _ = t1.Parse(
	`{{define "T1"}}ONE{{end}}
	{{define "T2"}}TWO{{end}}
	{{define "T3"}}{{template "T1"}} {{template "T2"}}{{end}}
	{{template "T3"}}`)
t2, _ = t2.Parse(
	`{{define "T4"}}ONE{{end}}
	{{define "T2"}}TWOO{{end}}
	{{define "T3"}}{{template "T4"}} {{template "T2"}}{{end}}
	{{template "T3"}}`)

	_ = t1.Execute(os.Stdout, "a")
	_ = t2.Execute(os.Stdout, "a")

在上面的t1和t2中，它們共享同一個common，且t1.Parse()中定義了T1、T2和T3，t2.Parse()中定義了T4、T2和T3，且兩個T2的解析內(nèi)容不一樣(解析樹不一樣)。

因為T1、T2、T3、T4都會加入到t1和t2共享的common中，所以無論是通過t1還是通過t2這兩個關(guān)聯(lián)名稱都能找到T1、T2、T3、T4。但是后解析的會覆蓋先解析的，也就是說，無論是t1.Lookup("T2")還是t2.Lookup("T2")得到的T2對應(yīng)的template，都是在t2.Parse()中定義的。當(dāng)t1.Execute()的時候，會得到t2中定義的T2的值。

ONE TWOO
ONE TWOO

Parse()

Parse(string)方法用于解析給定的文本內(nèi)容string。用法上很簡單，前面也已經(jīng)用過幾次了，沒什么可解釋的。重點在于它的作用。

當(dāng)創(chuàng)建了一個模板對象后，會有一個與之關(guān)聯(lián)的common(如果不存在，template包中的各種函數(shù)、方法都會因為調(diào)用init()方法而保證common的存在)。只有在Parse()之后，才會將相關(guān)的template name放進(jìn)common中，表示這個模板已經(jīng)可用了，或者稱為已經(jīng)定義了(defined)，可用被Execute()或ExecuteTemplate()，也表示可用使用Lookup()和DefinedTemplates()來檢索模板。另外，調(diào)用了Parse()解析后，會將給定的FuncMap中的函數(shù)添加到common的FuncMap中，只有添加到common的函數(shù)，才可以在模板中使用。

Parse()方法是解析字符串的，且只解析New()出來的模板對象。如果想要解析文件中的內(nèi)容，見后文ParseFiles()、ParseGlob()。

Lookup()、DefinedTemplates()和Templates()方法

這三個方法都用于檢索已經(jīng)定義的模板，Lookup()根據(jù)template name來檢索并返回對應(yīng)的template，DefinedTemplates()則是返回所有已定義的templates。Templates()和DefinedTemplates()類似，但是它返回的是[]*Template，也就是已定義的template的slice。

前面多次說過，只有在解析之后，模板才加入到common結(jié)構(gòu)中，才算是已經(jīng)定義，才能被檢索或執(zhí)行。

當(dāng)檢索不存在的templates時，Lookup()將返回nil。當(dāng)common中沒有模板，DefinedTemplates()將返回空字符串""，Templates()將返回空的slice。

func main() {
	t1 := template.New("test1")
	t2 := t1.New("test2")
	t1, _ = t1.Parse(
		`{{define "T1"}}ONE{{end}}
		{{define "T2"}}TWO{{end}}
		{{define "T3"}}{{template "T1"}} {{template "T2"}}{{end}}
		{{template "T3"}}`)
	t2, _ = t2.Parse(
		`{{define "T4"}}ONE{{end}}
		{{define "T2"}}TWOO{{end}}
		{{define "T3"}}{{template "T4"}} {{template "T2"}}{{end}}
		{{template "T3"}}`)

	fmt.Println(t1.DefinedTemplates())
	fmt.Println(t2.DefinedTemplates())
	fmt.Println(t2.Templates())
}

返回結(jié)果：

; defined templates are: "T1", "T2", "T3", "test1", "T4", "test2"
; defined templates are: "test1", "T4", "test2", "T1", "T2", "T3"
[0xc04201c280 0xc042064100 0xc04201c1c0 0xc04201c2c0 0xc04201c300 0xc042064080]

從結(jié)果可見，返回的順序雖然不一致，但包含的template name是完全一致的。

Clone()方法

Clone()方法用于克隆一個完全一樣的模板，包括common結(jié)構(gòu)也會完全克隆。

t1 := template.New("test1")
t1 = t1.Parse(...)
t2 := t1.New("test2")
t2 = t2.Parse(...)

t3, err := t1.Clone()
if err != nil {
	panic(err)
}

這里的t3和t1在內(nèi)容上完全一致，但在內(nèi)存中它們是兩個不同的對象。但無論如何，目前t3中會包含t1和t2共享的common，即使t2中定義了{{define "Tx"}}...{{end}}，這個Tx也會包含在t3中。

因為是不同的對象，所以修改t3，不會影響t1/t2。

看下面的例子：

func main() {
	t1 := template.New("test1")
	t2 := t1.New("test2")
	t1, _ = t1.Parse(
		`{{define "T1"}}ONE{{end}}
		{{define "T2"}}TWO{{end}}
		{{define "T3"}}{{template "T1"}} {{template "T2"}}{{end}}
		{{template "T3"}}`)
	t2, _ = t2.Parse(
		`{{define "T4"}}ONE{{end}}
		{{define "T2"}}TWOO{{end}}
		{{define "T3"}}{{template "T4"}} {{template "T2"}}{{end}}
		{{template "T3"}}`)

	t3, err := t1.Clone()
	if err != nil {
		panic(err)
	}

    // 結(jié)果完全一致
	fmt.Println(t1.Lookup("T4"))
	fmt.Println(t3.Lookup("T4"))
    
    // 修改t3
	t3,_ = t3.Parse(`{{define "T4"}}one{{end}}`)
    // 結(jié)果將不一致
	fmt.Println(t1.Lookup("T4"))
	fmt.Println(t3.Lookup("T4"))
}

Must()函數(shù)

正常情況下，很多函數(shù)、方法都返回兩個值，一個是想要返回的值，一個是err信息。template包中的函數(shù)、方法也一樣如此。

但有時候不想要err信息，而是直接取第一個返回值，并賦值給變量。操作大概是這樣的：

t1 := template.New("ttt")
t1,err := t1.Parse(...)
if err != nil {
    panic(err)
}
...

Must()函數(shù)將上面的過程封裝了，使得Must()可以簡化上面的操作：

func Must(t *Template, err error) *Template {
	if err != nil {
		panic(err)
	}
	return t
}

當(dāng)某個返回*Template,err的函數(shù)、方法需要直接使用時，可用將其包裝在Must()中，它會自動在有err的時候panic，無錯的時候只返回其中的*Template。

這在賦值給變量的時候非常簡便，例如：

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

ParseFiles()和ParseGlob()

Parse()只能解析字符串，要解析文件中的內(nèi)容，需要使用ParseFiles()或ParseGlob()。

template包中有ParseFiles()和ParseGlob()函數(shù)，也有ParseFiles()和ParseGlob()方法。

這兩個函數(shù)和這兩個方法的區(qū)別，看一下文檔就很清晰：

$ go doc template.ParseFiles
func ParseFiles(filenames ...string) (*Template, error)
    ParseFiles creates a new Template and parses the template definitions from
    the named files. The returned template's name will have the (base) name and
    (parsed) contents of the first file. There must be at least one file. If an
    error occurs, parsing stops and the returned *Template is nil.

$ go doc template.template.ParseFiles
func (t *Template) ParseFiles(filenames ...string) (*Template, error)
    ParseFiles parses the named files and associates the resulting templates
    with t. If an error occurs, parsing stops and the returned template is nil;
    otherwise it is t. There must be at least one file.

解釋很清晰。ParseFiles()函數(shù)是直接解析一個或多個文件的內(nèi)容，并返回第一個文件名的basename作為Template的名稱，也就是說這些文件的template全都關(guān)聯(lián)到第一個文件的basename上。ParseFiles()方法則是解析一個或多個文件的內(nèi)容，并將這些內(nèi)容關(guān)聯(lián)到t上。

看示例就一目了然。

例如，當(dāng)前go程序的目錄下有3個文件：a.cnf、b.cnf和c.cnf，它們的內(nèi)容無所謂，反正空內(nèi)容也可以解析。

func main() {
	t1,err := template.ParseFiles("a.cnf","b.cnf","c.cnf")
	if err != nil {
		panic(err)
	}
	fmt.Println(t1.DefinedTemplates())
	fmt.Println()
	fmt.Println(t1)
	fmt.Println(t1.Lookup("a.cnf"))
	fmt.Println(t1.Lookup("b.cnf"))
	fmt.Println(t1.Lookup("c.cnf"))
}

輸出結(jié)果：

; defined templates are: "a.cnf", "b.cnf", "c.cnf"

&{a.cnf 0xc0420ae000 0xc042064140  }
&{a.cnf 0xc0420ae000 0xc042064140  }
&{b.cnf 0xc0420bc000 0xc042064140  }
&{c.cnf 0xc0420bc100 0xc042064140  }

從結(jié)果中可以看到，已定義的template name都是文件的basename，且t1和a.cnf這個template是完全一致的，即t1是文件列表中的第一個模板對象。

結(jié)構(gòu)如下圖：

理解了ParseFiles()函數(shù)，理解ParseFiles()方法、ParseGlob()函數(shù)、ParseGlob()方法，應(yīng)該不會再有什么問題。但是還是有需要注意的地方：

func main() {
	t1 := template.New("test")
	t1,err := t1.ParseFiles("a.cnf","b.cnf","c.cnf")
	if err != nil {
		panic(err)
	}
    // 先注釋下面這行
	//t1.Parse("")
	fmt.Println(t1.DefinedTemplates())
	fmt.Println()
	fmt.Println(t1)
	fmt.Println(t1.Lookup("a.cnf"))
	fmt.Println(t1.Lookup("b.cnf"))
	fmt.Println(t1.Lookup("c.cnf"))
}

執(zhí)行結(jié)果：

; defined templates are: "a.cnf", "b.cnf", "c.cnf"

&{test <nil> 0xc0420640c0  }
&{a.cnf 0xc0420b0000 0xc0420640c0  }
&{b.cnf 0xc0420be000 0xc0420640c0  }
&{c.cnf 0xc0420be100 0xc0420640c0  }

發(fā)現(xiàn)template.New()函數(shù)創(chuàng)建的模板對象test并沒有包含到common中。為什么？

因為t.ParseFiles()、t.ParseGlob()方法的解析過程是獨立于t之外的，它們只解析文件內(nèi)容，不解析字符串。而New()出來的模板，需要Parse()方法來解析才會加入到common中。

將上面的注釋行取消掉，執(zhí)行結(jié)果將如下：

; defined templates are: "a.cnf", "b.cnf", "c.cnf", "test"

&{test 0xc0420bc200 0xc0420640c0  }
&{a.cnf 0xc0420ae000 0xc0420640c0  }
&{b.cnf 0xc0420bc000 0xc0420640c0  }
&{c.cnf 0xc0420bc100 0xc0420640c0  }

具體原因可分析parseFiles()源碼：

func parseFiles(t *Template, filenames ...string) (*Template, error) {
	if len(filenames) == 0 {
		// Not really a problem, but be consistent.
		return nil, fmt.Errorf("template: no files named in call to ParseFiles")
	}
	for _, filename := range filenames {
		b, err := ioutil.ReadFile(filename)
		if err != nil {
			return nil, err
		}
		s := string(b)

		// name為文件名的basename部分
		name := filepath.Base(filename)

		var tmpl *Template
		if t == nil {
			t = New(name)
		}
		// 如果調(diào)用t.Parsefiles()，則t.Name不為空
		// name也就不等于t.Name
		// 于是新New(name)一個模板對象給tmpl
		if name == t.Name() {
			tmpl = t
		} else {
			tmpl = t.New(name)
		}
		// 解析tmpl。如果選中了上面的else分支，則和t無關(guān)
		_, err = tmpl.Parse(s)
		if err != nil {
			return nil, err
		}
	}
	return t, nil
}

Execute()和ExecuteTemplate()

這兩個方法都可以用來應(yīng)用已經(jīng)解析好的模板，應(yīng)用表示對需要評估的數(shù)據(jù)進(jìn)行操作，并和無需評估數(shù)據(jù)進(jìn)行合并，然后輸出到io.Writer中：

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

兩者的區(qū)別在于Execute()是應(yīng)用整個common中已定義的模板對象，而ExecuteTemplate()可以選擇common中某個已定義的模板進(jìn)行應(yīng)用。

例如：

func main() {
	t1 := template.New("test1")
	t1, _ = t1.Parse(`{{define "T1"}}ONE{{end}}
		{{- define "T2"}}TWO{{end}}
		{{- define "T3"}}{{template "T1"}} {{template "T2"}}{{end}}
		{{- template "T3"}}`)
	
	_ = t1.Execute(os.Stdout,"")
	fmt.Println()
	fmt.Println("-------------")
	_ = t1.ExecuteTemplate(os.Stdout, "T2", "")
}

輸出結(jié)果：

ONE TWO
-------------
TWO

FuncMap和Funcs()

template內(nèi)置了一系列函數(shù)，但這些函數(shù)畢竟有限，可能無法滿足特殊的需求。template允許我們定義自己的函數(shù)，添加到common中，然后就可以在待解析的內(nèi)容中像使用內(nèi)置函數(shù)一樣使用自定義的函數(shù)。

自定義函數(shù)的優(yōu)先級高于內(nèi)置的函數(shù)優(yōu)先級，即先檢索自定義函數(shù)，再檢索內(nèi)置函數(shù)。也就是說，如果自定義函數(shù)的函數(shù)名和內(nèi)置函數(shù)名相同，則內(nèi)置函數(shù)將失效。

本文只對此稍作解釋，本文的重點不是template的具體語法和用法。

在common結(jié)構(gòu)中，有一個字段是FuncMap類型的：

type common struct {
	tmpl   map[string]*Template
	option option
	muFuncs    sync.RWMutex // protects parseFuncs and execFuncs
	parseFuncs FuncMap
	execFuncs  map[string]reflect.Value
}

這個類型的定義為：

type FuncMap map[string]interface{}

它是一個map結(jié)構(gòu)，key為模板中可以使用的函數(shù)名，value為函數(shù)對象(為了方便稱呼，這里直接成為函數(shù))。函數(shù)必須只有1個值或2個值，如果有兩個值，第二個值必須是error類型的，當(dāng)執(zhí)行函數(shù)時err不為空，則執(zhí)行自動停止。

函數(shù)可以有多個參數(shù)。假如函數(shù)str有兩個參數(shù)，在待解析的內(nèi)容中調(diào)用函數(shù)str時，如果調(diào)用方式為{{str . "aaa"}}，表示第一個參數(shù)為當(dāng)前對象，第二個參數(shù)為字符串"aaa"。

假如，要定義一個將字符串轉(zhuǎn)換為大寫的函數(shù)，可以：

import "strings"
func upper(str string) string {
	return strings.ToUpper(str)
}

然后將其添加到FuncMap結(jié)構(gòu)中，并將此函數(shù)命名為"strupper"，以后在待解析的內(nèi)容中就可以調(diào)用"strupper"函數(shù)。

funcMap := template.FuncMap{
	"strupper": upper,
}

或者，直接將匿名函數(shù)放在FuncMap內(nèi)部：

funcMap := template.FuncMap{
	"strupper": func(str string) string { return strings.ToUpper(str) },
}

現(xiàn)在只是定義了一個FuncMap實例，這個實例中有一個函數(shù)。還沒有將它關(guān)聯(lián)到模板，嚴(yán)格地說還沒有將其放進(jìn)common結(jié)構(gòu)。要將其放進(jìn)common結(jié)構(gòu)，調(diào)用Funcs()方法(其實調(diào)用此方法也沒有將其放進(jìn)common，只有在解析的時候才會放進(jìn)common)：

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

例如：

funcMap := template.FuncMap{
	"strupper": func(str string) string { return strings.ToUpper(str) },
}
t1 := template.New("test")
t1 = t1.Funcs(funcMap)

這樣，和t1共享common的所有模板都可以調(diào)用"strupper"函數(shù)。

注意，必須在解析之前調(diào)用Funcs()方法，在解析的時候會將函數(shù)放進(jìn)common結(jié)構(gòu)。

下面是完整的示例代碼：

package main

import (
	"os"
	"strings"
	"text/template"
)

func main() {
	funcMap := template.FuncMap{
		"strupper": upper,
	}
	t1 := template.New("test1")
	tmpl, err := t1.Funcs(funcMap).Parse(`{{strupper .}}`)
	if err != nil {
		panic(err)
	}
	_ = tmpl.Execute(os.Stdout, "go programming")
}

func upper(str string) string {
	return strings.ToUpper(str)
}

上面調(diào)用了{{strupper .}}，這里的strupper是我們自定義的函數(shù)，"."是它的參數(shù)(注意，參數(shù)不是放進(jìn)括號里)。這里的"."代表當(dāng)前作用域內(nèi)的當(dāng)前對象，對于這個示例來說，當(dāng)前對象就是那段字符串對象"go programming"。