Go中的模板引擎：text/template与html/template详解

描述
Go标准库提供了两个功能强大的模板引擎包：text/template 和 html/template。text/template 用于生成文本输出（如代码、配置文件等），而 html/template 在其基础上增加了针对HTML输出的上下文感知自动转义功能，能有效防范XSS攻击。理解其数据驱动、逻辑轻量的设计哲学以及具体使用方法，是开发现代Web应用和文本生成工具的关键。

知识点详解

1. 核心概念：模板与数据驱动
模板引擎的核心思想是数据驱动。你将一个数据结构（通常是Go的struct、map等）传递给一个已解析的模板，模板引擎会根据模板中定义的指令，将数据“注入”到模板的固定结构中，生成最终的文本。

• 模板（Template）：一个文本格式的蓝图，其中包含静态文本和动态的“动作（Action）”。
• 动作（Action）：由双花括号 {{ 和 }} 包裹的特殊指令，如 {{.FieldName}}，用于插入数据或执行控制逻辑。
• 数据对象（Data Object）：传递给模板执行的数据，在模板内部通过点号（.）来访问。

2. 创建与解析模板
第一步是创建一个模板对象并解析模板文本。

package main

import (
    "os"
    "text/template" // 或 "html/template"
)

func main() {
    // 1. 定义模板文本。`{{.}}` 表示输出整个当前数据对象。
    const tplText = `Hello, {{.}}!`

    // 2. 创建一个新模板并解析文本。
    //    `New` 为模板命名，`Parse` 方法解析传入的字符串。
    tmpl, err := template.New("greeting").Parse(tplText)
    if err != nil {
        panic(err)
    }

    // 3. 执行模板：将数据应用于模板，并将结果写入输出流（这里为标准输出）。
    data := "World"
    err = tmpl.Execute(os.Stdout, data) // 输出：Hello, World!
    if err != nil {
        panic(err)
    }
}

3. 访问复杂数据
当数据是结构体或映射时，可以使用点号访问其字段或键值。

type User struct {
    Name string
    Age  int
}

func main() {
    const tplText = `User: {{.Name}}, Age: {{.Age}}`

    tmpl, err := template.New("user").Parse(tplText)
    if err != nil {
        panic(err)
    }

    user := User{Name: "Alice", Age: 30}
    err = tmpl.Execute(os.Stdout, user) // 输出：User: Alice, Age: 30
    if err != nil {
        panic(err)
    }
}

4. 模板动作（Action）详解
动作是模板的灵魂，提供了变量、循环、条件判断等功能。

• 变量（Variables）：可以捕获动作的结果供后续使用。

  // {{$variableName := .Value}} 定义变量
  // {{$variableName}} 使用变量
  const tplText = `{{$name := .Name}}The name is {{$name}}.`
  

• 循环（Range）：遍历数组、切片、映射或通道。

  type Inventory struct {
      Items []string
  }
  
  const tplText = `
  Items:
  {{range .Items}}
  - {{.}} {{/* 在循环内，点号（.）代表当前迭代的项 */}}
  {{end}}
  `
  // 输入 Inventory{Items: []string{"A", "B", "C"}}
  // 输出：
  // Items:
  // - A
  // - B
  // - C
  

• 条件判断（If）：根据条件决定是否渲染某部分模板。

  const tplText = `Welcome, {{.Name}}! {{if .IsAdmin}} (Admin) {{end}}`
  // 如果 IsAdmin 为 true，则输出 "Welcome, Alice! (Admin)"
  // 如果为 false，则输出 "Welcome, Alice! "
  

• With：改变当前点号（.）的上下文。

  type Page struct {
      Title string
      Body  struct {
          Content string
      }
  }
  // 不使用 with，访问深层结构需要 {{.Body.Content}}
  // 使用 with 可以简化：
  const tplText = `
  Title: {{.Title}}
  {{with .Body}}
  Content: {{.Content}} {{/* 这里的 . 现在是 Page.Body */}}
  {{end}}
  `
  

• 模板嵌套（Template Inclusion）：定义可复用的模板块，并在其他模板中调用。

  const masterTpl = `
  Page Start
  {{template "content" .}} {{/* 执行名为 "content" 的模板，并传递当前数据（.） */}}
  Page End
  `
  
  const contentTpl = `
  {{define "content"}} {{/* 定义一个名为 "content" 的模板 */}}
  This is the main content: {{.Message}}
  {{end}}
  `
  
  func main() {
      // 先解析包含子模板定义的模板
      tmpl, err := template.New("master").Parse(masterTpl)
      if err != nil {
          panic(err)
      }
      // 然后解析定义了 "content" 的模板，必须关联到同一个模板对象
      _, err = tmpl.Parse(contentTpl)
      if err != nil {
          panic(err)
      }
  
      data := struct{ Message string }{Message: "Hello!"}
      tmpl.Execute(os.Stdout, data)
      // 输出：
      // Page Start
      // This is the main content: Hello!
      // Page End
  }
  

5. 函数（Functions）
模板中可以调用自定义函数或内置函数，极大地增强了模板的表现力。

• 内置函数：如 len（求长度），index（索引），printf（格式化输出）等。

  const tplText = `There are {{len .Items}} items. The first is {{index .Items 0}}.`
  

• 自定义函数：使用 template.FuncMap 注册，然后在模板中调用。

  func main() {
      // 1. 定义函数映射。键为模板中使用的函数名，值为Go函数。
      funcMap := template.FuncMap{
          "toUpper": strings.ToUpper,
          "add":     func(a, b int) int { return a + b },
      }
  
      // 2. 创建模板时传入函数映射。必须使用 `Funcs` 在 `Parse` 之前。
      const tplText = `Shout: {{. | toUpper}}, Sum: {{add 1 2}}.`
      tmpl, err := template.New("funcs").Funcs(funcMap).Parse(tplText)
      if err != nil {
          panic(err)
      }
  
      // 3. 执行
      err = tmpl.Execute(os.Stdout, "hello") // 输出：Shout: HELLO, Sum: 3.
      if err != nil {
          panic(err)
      }
  }
  

6. text/template 与 html/template 的关键区别
html/template 包为HTML上下文提供了至关重要的安全特性。

• 自动转义（Auto-escaping）：html/template 会根据上下文（HTML标签内、属性内、JavaScript内等）自动对动态数据进行正确的转义。

  // 假设数据是：`<script>alert('xss')</script>`
  
  // 使用 text/template (危险！)
  // 输出: <div>Welcome, <script>alert('xss')</script>!</div>
  // 浏览器会执行该脚本，造成XSS攻击。
  
  // 使用 html/template (安全)
  // 输出: <div>Welcome, &lt;script&gt;alert(&#39;xss&#39;)&lt;/script&gt;!</div>
  // 特殊字符被转义为HTML实体，浏览器会将其显示为普通文本，不会执行。
  

• 安全字符串（template.HTML）：如果你确信某段内容是安全的HTML并且不需要转义，可以将其声明为 template.HTML 类型。但需谨慎使用。

  import "html/template"
  // ...
  data := struct {
      SafeContent   template.HTML
      UnsafeContent string
  }{
      SafeContent:   template.HTML("<b>Bold Text</b>"), // 不会被转义
      UnsafeContent: "<i>Italic Text</i>",             // 会被转义
  }
  const tplText = `Safe: {{.SafeContent}}, Unsafe: {{.UnsafeContent}}`
  // 输出：Safe: Bold Text, Unsafe: &lt;i&gt;Italic Text&lt;/i&gt;
  

总结
Go的模板引擎设计精巧，强调逻辑与展示分离。text/template 适用于通用文本生成，而 html/template 是构建安全Web视图的首选。掌握其数据绑定、动作控制、函数扩展以及理解 html/template 的自动转义机制，是高效、安全使用Go进行文本处理和Web开发的基础。