如何从已解析的模板中获取模板 'actions' 的地图或列表？

Question

所以我想以某种方式将模板中定义的所有 {{ .blahblah }} 操作作为字符串片段。

例如，如果我有这个模板：

<h1>{{ .name }} {{ .age }}</h1>

我希望能够得到[]string{"name", "age"}。假设模板具有方法 func (t *Template) Fields() []string:

t := template.New("cooltemplate").Parse(`<h1>{{ .name }} {{ .age }}</h1>`)
if t.Fields() == []string{"name", "age"} {
    fmt.Println("Yay, now I know what fields I can pass in!")
    // Now lets pass in the name field that we just discovered.
    _ = t.Execute(os.Stdout, map[string]string{"name": "Jack", "age":"120"})
}

有没有办法像这样检查已解析的模板？
谢谢！

Answer 1

前言：正如 Voker 所建议的，Template.Tree 字段是 "exported only for use by html/template and should be treated as unexported by all other clients."

你不应该依赖这样的东西来为模板执行提供输入。您必须知道要执行的模板及其期望的数据。您不应该 "explore" 在运行时为它提供参数。

解析模板的价值是 template.Template (either text/template or html/template, they have the same API). This template represents the templates as a tree of type parse.Tree。文本模板包含的所有内容都存储在这棵树的节点中，包括静态文本、动作等。

话虽如此，您可以遍历这棵树并查找标识此类访问字段或调用函数的操作的节点。节点类型为parse.Node which has a Node.Type() method returning its type. The possible types are defined as constants in the parse package, next to the parse.NodeType类型，例如

const (
        NodeText    NodeType = iota // Plain text.
        NodeAction                  // A non-control action such as a field evaluation.
        NodeBool                    // A boolean constant.
        NodeChain                   // A sequence of field accesses.
        NodeCommand                 // An element of a pipeline.
        NodeDot                     // The cursor, dot.

        NodeField      // A field or method name.
        NodeIdentifier // An identifier; always a function name.
        NodeIf         // An if action.
        NodeList       // A list of Nodes.
        NodeNil        // An untyped nil constant.
        NodeNumber     // A numerical constant.
        NodePipe       // A pipeline of commands.
        NodeRange      // A range action.
        NodeString     // A string constant.
        NodeTemplate   // A template invocation action.
        NodeVariable   // A $ variable.
        NodeWith       // A with action.
)

所以这是一个递归遍历模板树的示例程序，并查找具有 NodeAction 类型的节点，即 "A non-control action such as a field evaluation."

这个解决方案只是一个演示，一个概念证明，它并不处理所有情况。

func ListTemplFields(t *template.Template) []string {
    return listNodeFields(t.Tree.Root, nil)
}

func listNodeFields(node parse.Node, res []string) []string {
    if node.Type() == parse.NodeAction {
        res = append(res, node.String())
    }

    if ln, ok := node.(*parse.ListNode); ok {
        for _, n := range ln.Nodes {
            res = listNodeFields(n, res)
        }
    }
    return res
}

使用示例：

t := template.Must(template.New("cooltemplate").
    Parse(`<h1>{{ .name }} {{ .age }}</h1>`))
fmt.Println(ListTemplFields(t))

输出（在 Go Playground 上尝试）：

[{{.name}} {{.age}}]

Answer 2

我碰巧需要大致相同的代码。在我的用例中，我们允许用户在一侧创建模板，并输入 map[string]string 变量以用于以不同形式呈现。

这是我到目前为止想出的代码（受 icza 的回答启发）：

// Extract the template vars required from *simple* templates.
// Only works for top level, plain variables. Returns all problematic parse.Node as errors.
func RequiredTemplateVars(t *template.Template) ([]string, []error) {
    var res []string
    var errors []error
    var ln *parse.ListNode
    ln = t.Tree.Root
Node:
    for _, n := range ln.Nodes {
        if nn, ok := n.(*parse.ActionNode); ok {
            p := nn.Pipe
            if len(p.Decl) > 0 {
                errors = append(errors, fmt.Errorf("Node %v not supported", n))
                continue Node
            }
            for _, c := range p.Cmds {
                if len(c.Args) != 1 {
                    errors = append(errors, fmt.Errorf("Node %v not supported", n))
                    continue Node
                }
                if a, ok := c.Args[0].(*parse.FieldNode); ok {
                    if len(a.Ident) != 1 {
                        errors = append(errors, fmt.Errorf("Node %v not supported", n))
                        continue Node
                    }
                    res = append(res, a.Ident[0])
                } else {
                    errors = append(errors, fmt.Errorf("Node %v not supported", n))
                    continue Node
                }

            }
        } else {
            if _, ok := n.(*parse.TextNode); !ok {
                errors = append(errors, fmt.Errorf("Node %v not supported", n))
                continue Node
            }
        }
    }
    return res, errors
}

https://play.golang.org/p/nH95B45jUmI

Answer 3

对@icza 的回答进行了小幅优化，也许会有一点帮助:)

func listNodeFieldsV2(node parse.Node) []string {
    var res []string
    if node.Type() == parse.NodeAction {
        res = append(res, node.String())
    }
    if ln, ok := node.(*parse.ListNode); ok {
        for _, n := range ln.Nodes {
            res = append(res, listNodeFieldsV2(n)...)
        }
    }
    return res
}

如何从已解析的模板中获取模板 'actions' 的地图或列表？

How to get a map or list of template 'actions' from a parsed template?

templates

go

go-templates