Question

我没有看到使用动态名称调用模板（文本或html）的方法。例如：

这有效：

{{template "Blah" .}}

在模板调用中出现“意外”$ BlahVar的错误：

{{$BlahVar := "Blah"}}
{{template $BlahVar .}}

我试图解决的整体问题是我需要根据配置文件有条件地渲染模板 - 所以我不知道模板的名称提前。显然我可以在FuncMap中放置一个函数，它只进行单独的模板解析和调用，并返回该结果但是想知道是否有更好的方法。

Answer 1

作为对此的说明和后续行动，我最终得到了这个问题的两个主要答案：1）尽量避免这种情况。在一些情况下，简单的if语句工作正常。 2）我能够使用FuncMap中的一个函数完成此操作，该函数只进行单独的渲染。它不是世界上最伟大的东西，但它确实起作用并解决了这个问题。这是一个完整的独立演示，展示了这个想法：

package main

import (
    "bytes"
    "html/template"
    "os"
)

func main() {

    var err error

    // our main template here calls a sub template
    tpl := template.New("main")

    // provide a func in the FuncMap which can access tpl to be able to look up templates
    tpl.Funcs(map[string]interface{}{
        "CallTemplate": func(name string, data interface{}) (ret template.HTML, err error) {
            buf := bytes.NewBuffer([]byte{})
            err = tpl.ExecuteTemplate(buf, name, data)
            ret = template.HTML(buf.String())
            return
        },
    })

    // this is the main template
    _, err = tpl.Parse(`

{{$Name := "examplesubtpl"}}

from main template

{{CallTemplate $Name .}}

`)
    if err != nil {
        panic(err)
    }

    // whatever code to dynamically figure out what templates to load

    // a stub just to demonstrate
    _, err = tpl.New("examplesubtpl").Parse(`

this is from examplesubtpl - see, it worked!

`)
    if err != nil {
        panic(err)
    }

    err = tpl.Execute(os.Stdout, map[string]interface{}{})
    if err != nil {
        panic(err)
    }

}

Answer 2

另一种方式，虽然可能不是更好的方法，但是要有单独的模板文件，它们都提供相同的命名模板。例如，假设您有一个网页的共享布局：

<html>
  ...
  <body>
    {{template "body" .}}
  </body>
</html>

在每个页面中执行此操作：

{{define "body"}}
  This will be in the body
{{end}}

然后将它们合并到代码中：

func compileTemplate(layout, name string) (*template.Template, error) {
    tpl := template.New(name)
    tpl, err := tpl.ParseFiles(
        "views/layouts/"+layout+".htm",
        "views/"+name+".htm",
    )
    if err != nil {
        return nil, err
    }
    return tpl, nil
}

Answer 3

使用 htmltemplate.HTML（）将已解析的模板（“电子邮件/测试”）注入另一个模板（“电子邮件/主”）

htmlTplEngine := htmltemplate.New("htmlTplEngine")


_, htmlTplEngineErr := htmlTplEngine.ParseGlob("views/email/*.html")
if nil != htmlTplEngineErr {
    log.Panic(htmlTplEngineErr.Error())
}

var contentBuffer bytes.Buffer
if err := htmlTplEngine.ExecuteTemplate(&contentBuffer, "email/test", params); err != nil {
    return "", "", errors.Wrap(err, "execute content html")
}

var templateBuf bytes.Buffer
if err := htmlTplEngine.ExecuteTemplate(
    &templateBuf,
    "email/main",
    map[string]interface{}{
        "Content": htmltemplate.HTML(contentBuffer.String()),
        "Lang":    language,
    },
); err != nil {
    return "", "", errors.Wrap(err, "execute html template")
}

在“电子邮件/主”上

{{define "email/main"}}

My email/test template: {{.Content}}

{{end}}

Answer 4

我梦寐以求的一个有才华的开发人员的另一种方法是对Template实例进行后处理，以找到未定义的任何模板，并查看文件系统中的匹配文件，并为每个找到的文件解析它;然后渲染。

这为您提供了如下设置：

视图/ index.html中：

{{template "/includes/page-wrapper.html" .}}

{{define "body"}}
<div>Page guts go here</div>
{{end}}

{{define "head_section"}}
<title>Title Tag</title>
{{end}}

包括/页-wrapper.html：

<html>
<head>
{{block "head_section" .}}{{end}}
<head>
<body>

{{template "body" .}}

</body>
</html>

您的ServeHTTP()方法在“views”目录中查找文件，加载并解析它，然后调用TmplIncludeAll()（下面）。

我最终将这个相同的基本概念改编为几个功能，如下所示。 t是解析后但在渲染之前的模板。 fs是“观看”和“包含”直播的目录（如上所述）。

func TmplIncludeAll(fs http.FileSystem, t *template.Template) error {

    tlist := t.Templates()
    for _, et := range tlist {
        if et != nil && et.Tree != nil && et.Tree.Root != nil {
            err := TmplIncludeNode(fs, et, et.Tree.Root)
            if err != nil {
                return err
            }
        }
    }

    return nil
}

func TmplIncludeNode(fs http.FileSystem, t *template.Template, node parse.Node) error {

    if node == nil {
        return nil
    }

    switch node := node.(type) {

    case *parse.TemplateNode:
        if node == nil {
            return nil
        }

        // if template is already defined, do nothing
        tlist := t.Templates()
        for _, et := range tlist {
            if node.Name == et.Name() {
                return nil
            }
        }

        t2 := t.New(node.Name)

        f, err := fs.Open(node.Name)
        if err != nil {
            return err
        }
        defer f.Close()

        b, err := ioutil.ReadAll(f)
        if err != nil {
            return err
        }

        _, err = t2.Parse(string(b))
        if err != nil {
            return err
        }

        // start over again, will stop recursing when there are no more templates to include
        return TmplIncludeAll(fs, t)

    case *parse.ListNode:

        if node == nil {
            return nil
        }

        for _, node := range node.Nodes {
            err := TmplIncludeNode(fs, t, node)
            if err != nil {
                return err
            }
        }

    case *parse.IfNode:
        if err := TmplIncludeNode(fs, t, node.BranchNode.List); err != nil {
            return err
        }
        if err := TmplIncludeNode(fs, t, node.BranchNode.ElseList); err != nil {
            return err
        }

    case *parse.RangeNode:
        if err := TmplIncludeNode(fs, t, node.BranchNode.List); err != nil {
            return err
        }
        if err := TmplIncludeNode(fs, t, node.BranchNode.ElseList); err != nil {
            return err
        }

    case *parse.WithNode:
        if err := TmplIncludeNode(fs, t, node.BranchNode.List); err != nil {
            return err
        }
        if err := TmplIncludeNode(fs, t, node.BranchNode.ElseList); err != nil {
            return err
        }

    }

    return nil
}

这是我最喜欢的方法，我已经使用了一段时间了。它的优点是只有一个模板渲染，错误消息很好而且干净，Go模板标记非常易读且很明显。如果html / template.Template的内容使这更容易实现，那将是很好的，但它总体上是一个很好的解决方案IMO。

使用动态名称调用其他模板

4 个答案: