Go的模板引擎通過(guò)text/template和html/template包提供強(qiáng)大的動(dòng)態(tài)內(nèi)容生成功能，其中html/template具有自動(dòng)轉(zhuǎn)義功能以防止XSS攻擊，因此生成HTML時(shí)應(yīng)優(yōu)先使用。1. 使用{{}}語(yǔ)法插入變量、條件判斷和循環(huán)，如{{.FieldName}}訪問(wèn)結(jié)構(gòu)體字段，{{if}}和{{range}}實(shí)現(xiàn)邏輯控制。2. 模板支持struct、slice和map等Go數(shù)據(jù)結(jié)構(gòu)，range中點(diǎn)號(hào)代表當(dāng)前迭代元素。3. 可通過(guò)define定義命名模板并用template指令復(fù)用。4. html/template自動(dòng)轉(zhuǎn)義HTML特殊字符，若需渲染原始HTML應(yīng)使用template.HTML類型但僅限可信輸入。5. 利用block和define模擬模板繼承，實(shí)現(xiàn)布局復(fù)用。6. 最佳實(shí)踐包括：預(yù)解析模板、使用template.Must捕獲錯(cuò)誤、避免在模板中編寫復(fù)雜邏輯、通過(guò)ParseGlob加載多個(gè)模板文件。正確掌握點(diǎn)符號(hào)、動(dòng)作和轉(zhuǎn)義規(guī)則后，Go模板系統(tǒng)將成為構(gòu)建安全可靠應(yīng)用的有力工具。

Go’s built-in templating engine, found in the text/template and html/template packages, is a powerful and efficient way to generate dynamic content—whether that’s plain text, configuration files, or HTML web pages. It's especially popular in web development with Go, where safety and simplicity are key. Here’s a practical guide to help you get the most out of Go’s templating system.

1. Understanding text/template vs html/template

Go provides two main templating packages:

• text/template: General-purpose templating for any kind of text (e.g., config files, emails, CLI output).
• html/template: Built on top of text/template, but designed specifically for HTML with automatic context-aware escaping to prevent XSS attacks.

? Use html/template when generating HTML. It’s safer by default.

import (
    "text/template"  // for plain text
    "html/template"  // for HTML
)

2. Basic Template Syntax

Templates use double braces {{ }} to enclose actions. Common constructs include:

• {{.}} – refers to the current data (the “dot”)
• {{.FieldName}} – accesses a field in a struct
• {{if .Condition}}...{{end}} – conditional logic
• {{range .Items}}...{{end}} – loops over slices, maps, or channels
• {{template "name"}} – includes a named template

Example: Simple greeting

tmpl := `Hello, {{.Name}}!`
data := struct{ Name string }{Name: "Alice"}
t := template.New("greeting")
t, _ = t.Parse(tmpl)
t.Execute(os.Stdout, data)
// Output: Hello, Alice!

3. Structs, Slices, and Maps in Templates

Go templates work seamlessly with Go data structures.

Using a struct with a slice:

type Person struct {
    Name  string
    Hobbies []string
}

data := Person{
    Name:  "Bob",
    Hobbies: []string{"Golang", "Hiking", "Reading"},
}

tmpl := `
Name: {{.Name}}
Hobbies:
{{range .Hobbies}}- {{.}}
{{end}}
`

template.Must(template.New("person").Parse(tmpl)).Execute(os.Stdout, data)

Output:

Name: Bob
Hobbies:
- Golang
- Hiking
- Reading

Note: In range, the dot (.) changes to the current item in the iteration.

4. Control Structures: if, else, range

Go templates support basic logic.

• Use {{if .Value}}...{{else}}...{{end}}
• Empty slices, nil pointers, zero values evaluate to false

{{if .LoggedIn}}
  Welcome back, {{.Username}}!
{{else}}
  Please log in.
{{end}}

You can also compare values using built-in functions (from eq, ne, lt, gt, etc.):

{{if eq .Status "active"}}
  <p>Status: Active</p>
{{end}}

These comparison functions come from the template’s built-in functions, not Go code.

5. Creating Reusable Templates with define and template

You can define named templates and include them.

const tmpl = `
{{define "Greet"}}Hello, {{.}}!{{end}}

{{template "Greet" "Alice"}}
{{template "Greet" "Bob"}}
`

t, _ := template.New("main").Parse(tmpl)
t.Execute(os.Stdout, nil)

This is useful for headers, footers, or reusable UI components in web apps.

6. Using html/template Safely

When generating HTML, always use html/template to avoid XSS.

import "html/template"

data := struct {
    Content string
}{Content: "<script>alert('hack')</script>"}

tmpl := `<p>{{.Content}}</p>`
t, _ := template.New("safe").Parse(tmpl)
t.Execute(os.Stdout, data)

? Output:

<p><script>alert(&#39;hack&#39;)</script></p>

The content is automatically escaped. If you really need raw HTML, use template.HTML type:

type Page struct {
    Content template.HTML
}

data := Page{Content: template.HTML("<strong>Safe HTML</strong>")}

Now {{.Content}} will render without escaping.

?? Only do this with trusted input.

7. Template Inheritance with Blocks (via define and block)

While Go doesn’t have direct inheritance, you can simulate layout templates using define and template.

Base layout (layout.html):

<!DOCTYPE html>
<html>
<head><title>{{block "title" .}}Default Title{{end}}</title></head>
<body>
  <header><h1>My Site</h1></header>
  <main>{{block "content" .}}Default content{{end}}</main>
</body>
</html>

Page template:

{{define "title"}}Home{{end}}
{{define "content"}}
  <p>Welcome to the home page!</p>
{{end}}

Go code:

tpl := template.Must(template.New("base").ParseFiles("layout.html", "home.html"))
tpl.ExecuteTemplate(os.Stdout, "base", nil)

This pattern lets you build modular, reusable layouts.

8. Best Practices

• ? Always use html/template for HTML output.
• ? Pre-parse templates in production (don’t parse on every request).
• ? Use template.Must() during initialization to catch errors early.
• ? Keep logic minimal in templates—do heavy lifting in Go code.
• ? Organize templates into files and use ParseFiles or ParseGlob.

// Load all templates from a folder
tpl := template.Must(template.ParseGlob("templates/*.html"))

Go’s templating engine might feel minimal compared to other languages, but its simplicity, type safety, and security features make it ideal for building reliable applications—especially web servers.

Basically, once you get the hang of the dot, actions, and escaping rules, it becomes a solid tool in your Go toolkit.

以上是GO的模板引擎指南的詳細(xì)內(nèi)容。更多信息請(qǐng)關(guān)注PHP中文網(wǎng)其他相關(guān)文章！