template 概述

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

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

解析流程

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

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

下邊我們看一段簡(jiǎn)單的 使用template 的代碼

package main
import (
   "os"
   "text/template"
)
var templateStr = `
package main
func main() {
    fmt.Println("Hello, {{.Name}}!")
}
`
func main() {
   // 創(chuàng)建template對(duì)象
   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)
   }
}

運(yùn)行后可以看到輸出:

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

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

template.New 創(chuàng)建了一個(gè)template對(duì)象

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

Parse階段

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

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

其中 TextNode 直接存儲(chǔ)了文本, ActionNode 會(huì)解析出 .Name 變量, 將文本字符串解析成為 parse.Tree 對(duì)象之后, 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é)點(diǎn)
   state.walk(value, t.Root)
   return
}

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

// 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é)點(diǎn), 遞歸 
      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階段分為兩步處理, 第一步, 是解析語法樹, 把對(duì)應(yīng)的變量替換成實(shí)際的值, 對(duì)應(yīng)方法evalPipeline(), 第二步是把生成的結(jié)果輸出, 對(duì)應(yīng)了代碼printValue()
• TextNode TextNode 就很簡(jiǎn)單了, 直接把Node存儲(chǔ)的文本原封不動(dòng)的打印, 直接使用了 Write()方法寫入

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

至此, 整個(gè)流程完成.

小結(jié)

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

• Parse階段

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

• Execute階段

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

template功能用在代碼生成上非常簡(jiǎn)單高效, 諸如腳手架生成基礎(chǔ)開發(fā)模板, 還有 protobuf 等 IDL 生成代碼都很方便,更多的實(shí)踐應(yīng)用，請(qǐng)關(guān)注腳本之家其它相關(guān)文章！

最新評(píng)論