template 概述

最近在做腳手架相關(guān)的內(nèi)容, 研究了一下 Go 的 text/template 包, 接下來跟大家分享下 template 的基本原理.

在 Golang 的標準庫中, 有兩個和 template 有關(guān)的包, 一個是 html/template, 另外一個是 text/template, 這兩個包的主要區(qū)別是 html 版本加入了很多對 js字符串 和 html標簽 的處理, 下面我們主要用 text/template 作為案例說明.

解析流程

首先, 無論是使用 template.Parse() 還是 template.New() 都會創(chuàng)建一個 *Template 對象, 用來管理整個處理流程.

模板處理主要分為兩個階段, 第一個階段是parse 階段, 在這個階段, 會把讀入的數(shù)據(jù), 不論是從文件讀入還是直接從字符串讀取的內(nèi)容, 統(tǒng)一解析成節(jié)點樹, 第二個階段是 execute 階段, 在這個階段, 會把傳進來的變量解析到節(jié)點樹上, 生成最終的輸出流, 然后寫入到 io.Writer 中.

下邊我們看一段簡單的 使用template 的代碼

package main
import (
   "os"
   "text/template"
)
var templateStr = `
package main
func main() {
    fmt.Println("Hello, {{.Name}}!")
}
`
func main() {
   // 創(chuàng)建template對象
   t := template.New("demo")
   // 解析模板內(nèi)容
   parse, err := t.Parse(templateStr)
   if err != nil {
      panic(err)
   }
   // 執(zhí)行解析
   data := map[string]string{"Name": "World"}
   err = parse.Execute(os.Stdout, data)
   if err != nil {
      panic(err)
   }
}

運行后可以看到輸出:

package main
func main() {
    fmt.Println("Hello, World!")
}

接下來我們就一起來分析下執(zhí)行過程:

template.New 創(chuàng)建了一個template對象

// src/text/template/template.go
type Template struct {
   name string
   *parse.Tree
   *common
   leftDelim  string
   rightDelim string
}

Parse階段

其中 *parse.Tree 只在 html/template 中使用, 表示解析完成的模板, *common 里包含了解析過程中所有輸入的模板, 用一個 map 存儲, 之所以使用map, 是因為 template 支持 {{define block}} 這種嵌套模板, 每一個模板快都會被解析成一個 Template對象, 然后放到這個map里, 供模板之間引用. 下面我們重點看下, 每個模板解析完之后生成的 parse.Tree.

上邊的代碼生成的模板對象 t 包含的map只有一個元素, 元素的 Root屬性(即parse之后生成的 parse.Tree), 會有三個節(jié)點.

其中 TextNode 直接存儲了文本, ActionNode 會解析出 .Name 變量, 將文本字符串解析成為 parse.Tree 對象之后, Parse階段就執(zhí)行結(jié)束了, 接下來就是 Execute 階段.

Execute階段

// src/text/template/exec.go
func (t *Template) Execute(wr io.Writer, data any) error {
   return t.execute(wr, data)
}
func (t *Template) execute(wr io.Writer, data any) (err error) {
   defer errRecover(&err)
   // 使用反射解析傳入的參數(shù)
   value, ok := data.(reflect.Value)
   ...
   state := &state{
      tmpl: t,
      wr:   wr,
      vars: []variable{{"$", value}},
   }
   ...
   // 遍歷節(jié)點
   state.walk(value, t.Root)
   return
}

Execute階段開始的時候, 會先反射傳入的 data, 用來解析模板內(nèi)的變量, 接下來遍歷模板的Root 也就是從節(jié)點樹的根開始遍歷處理每個節(jié)點, 這里使用了遞歸的方式.

// src/text/template/exec.go
func (s *state) walk(dot reflect.Value, node parse.Node) {
   s.at(node)
   switch node := node.(type) {
   case *parse.ActionNode:
      val := s.evalPipeline(dot, node.Pipe)
      if len(node.Pipe.Decl) == 0 {
         s.printValue(node, val)
      }
   ...
   case *parse.ListNode:
       // 循環(huán)遍歷節(jié)點, 遞歸 
      for _, node := range node.Nodes {
         s.walk(dot, node)
      }
   ...
   case *parse.TextNode:
      if _, err := s.wr.Write(node.Text); err != nil {
         s.writeError(err)
      }
   ...
}

我們看下 ActionNode 和 TextNode 的處理

• ActionNode ActionNode 在Parse階段生成語法樹, 在Execute階段分為兩步處理, 第一步, 是解析語法樹, 把對應的變量替換成實際的值, 對應方法evalPipeline(), 第二步是把生成的結(jié)果輸出, 對應了代碼printValue()
• TextNode TextNode 就很簡單了, 直接把Node存儲的文本原封不動的打印, 直接使用了 Write()方法寫入

節(jié)點遍歷完成之后, 所有的文本已經(jīng)都輸出到 io.Writer 中, 模板執(zhí)行結(jié)束.

至此, 整個流程完成.

小結(jié)

text/template 的解析過程主要經(jīng)歷了兩個階段:

• Parse階段

在這個階段, 輸入內(nèi)容經(jīng)歷了從 template.Template 到 parse.NodeList 再到 parse.Node幾個步驟, 將純文本變成了可以統(tǒng)一處理的節(jié)點, 方便后續(xù)操作

• Execute階段

遍歷全部的 parse.Node, 根據(jù)不同的規(guī)則把每個node的內(nèi)容處理過之后, 輸出到 io.Writer里, 完成執(zhí)行