html/template.Clone 适合“公共布局相同、页面主体不同”的场景。最稳妥的写法是：先注册函数并解析公共模板，随后在任何执行发生前克隆；每个副本再解析自己的同名 content 定义，最后统一执行 layout。这样首页和后台页可以复用同一套页头、页脚与辅助模板，又不会互相覆盖。

本文依据 Go 标准库文档：https://pkg.go.dev/html/template#Template.Clone、https://pkg.go.dev/html/template#Template.Parse 与 https://pkg.go.dev/html/template#Template.ExecuteTemplate。判断是否用对只有两个标准：公共模板只解析一次；各派生模板渲染出的 content 不串页。

最小可用写法

公共模板先提供 layout 和一个非空的默认 content。派生函数克隆公共集合，再用页面定义覆盖副本里的 content：

package main

import (
    "html/template"
    "io"
)

var base = template.Must(template.New("root").Parse(`
{{define "layout"}}

公共导航
{{template "content" .}}
{{end}}
{{define "content"}}
默认内容
{{end}}
`))

func derive(pageDefinition string) *template.Template {
    // 必须在 base 第一次执行前克隆；副本拥有独立的关联模板命名空间。
    cloned := template.Must(base.Clone())
    // 页面定义用相同名称覆盖副本中的 content，不会修改 base。
    return template.Must(cloned.Parse(pageDefinition))
}

var homePage = derive(`{{define "content"}}
首页：{{.Message}}
{{end}}`)
var adminPage = derive(`{{define "content"}}
后台：{{.Message}}
{{end}}`)

func render(w io.Writer, page *template.Template, data any) error {
    // layout 是渲染入口，它会调用当前集合里的 content。
    return page.ExecuteTemplate(w, "layout", data)
}

这里不是复制一段 HTML 字符串，而是复制整个“已关联的命名模板集合”。homePage 和 adminPage 都保留 layout，但各自的 content 已经不同。

Clone 实际复制的是关联模板集合

标准库说明，Clone 返回模板及全部关联模板的副本。底层表示不要求逐字节复制，但关联模板的命名空间会被复制，因此在副本上继续 Parse，新增或重定义只落入该副本，不会回写原集合。

这正好对应页面派生：layout、header、footer 属于公共定义；首页和后台页分别在克隆后补入自己的 content。执行时，{{template "content" .}} 会在当前关联集合内查找，而不是去全局寻找。

派生多个页面变体

页面数量增加后，建议把“页面定义”和“构建动作”分开。构建函数只做克隆与解析，HTTP 处理函数只做查表与执行：

type ViewData struct {
    Title   string
    Message string
}

func buildPages() map[string]*template.Template {
    definitions := map[string]string{
        "home":  `{{define "content"}}
首页
{{.Message}}
{{end}}`,
        "admin": `{{define "content"}}
控制台
{{.Message}}
{{end}}`,
    }

    pages := make(map[string]*template.Template, len(definitions))
    for name, definition := range definitions {
        // 每次都从未执行的公共集合克隆，页面之间没有共享的可变定义。
        pages[name] = derive(definition)
    }
    return pages
}

var pages = buildPages()

func executePage(w io.Writer, name string, data ViewData) error {
    page, ok := pages[name]
    if !ok {
        // 未知页面由调用方处理，而不是退回到任意模板。
        return fmt.Errorf("unknown page %q", name)
    }
    return page.ExecuteTemplate(w, "layout", data)
}

上例需要在 import 中加入 fmt。生产项目可以把定义改为 ParseFS 或 ParseFiles；关键仍是每个页面都从同一份未执行的公共集合克隆，然后只在自己的副本上追加定义。

什么时候注册 FuncMap

模板文本引用的函数必须在解析该文本前注册。公共布局会用到的函数，应在构建 base 时先调用 Funcs；页面专用函数也要在解析页面定义前可见：

func buildBase() *template.Template {
    funcs := template.FuncMap{
        // 函数签名在构建期确定，模板文本解析时必须能够找到它。
        "upper": strings.ToUpper,
    }
    return template.Must(template.New("root").Funcs(funcs).Parse(commonSource))
}

func deriveWithFuncs(pageSource string) *template.Template {
    cloned := template.Must(buildBase().Clone())
    // Clone 后可以替换同名函数，但新增函数仍要早于引用它的 Parse。
    cloned.Funcs(template.FuncMap{"badge": func(s string) string { return "[" + s + "]" }})
    return template.Must(cloned.Parse(pageSource))
}

如果某个函数只在执行时换实现，Funcs 可以在克隆后替换同名函数；但模板里首次出现的新函数名，仍然必须在对应 Parse 前注册。

三条门禁：先解析、再克隆、最后执行

把模板生命周期拆成“构建输入、派生边界、执行边界”最容易排错。构建期允许 Funcs、Parse 和 Clone；执行开始后，不再向同一模板集合追加定义。最终缓存的是已经完成解析的页面集合，处理请求时只调用 ExecuteTemplate。

Clone 失败与重定义不生效

最常见的失败是先渲染公共模板，再尝试 Clone。官方文档明确说明：模板一旦执行过，Clone 会返回错误。因此不要在请求到来时临时克隆，应该在程序启动、依赖注入或热更新的独立构建阶段一次性完成。

另一个隐蔽问题是空定义。连续调用 Parse 可以在首次执行前重定义模板，但只有空白和注释的定义被视为空，不会覆盖已有模板体。下面的定义不会清空默认内容：

cloned := template.Must(base.Clone())

// 只有空白和模板注释的定义被视为空，不会替换原来的 content。
template.Must(cloned.Parse(`{{define "content"}}{{/* 暂无 */}}{{end}}`))

// 真正需要空输出时，加入会产生确定结果的表达式，或调整布局判断逻辑。
template.Must(cloned.Parse(`{{define "content"}}{{""}}{{end}}`))

还要避免把 New("content") 当作普通查找操作：同名模板已存在时，New 会替换并解除旧关联。页面覆盖优先使用清晰的 {{define "content"}} 配合 Parse。

并发执行和缓存方式

解析完成的模板可以安全地并发执行，所以页面模板集合适合在启动时构建并缓存。唯一要额外管理的是输出目标：多个并发执行共享同一个 io.Writer 时，字节可能交错。HTTP 场景通常每个请求有自己的 ResponseWriter；生成文件时则应为每个任务使用独立缓冲区。

func renderToBytes(page *template.Template, data ViewData) ([]byte, error) {
    var buf bytes.Buffer
    // 每次执行使用独立 Writer；模板集合保持只读，可被多个 goroutine 复用。
    if err := page.ExecuteTemplate(&buf, "layout", data); err != nil {
        return nil, err
    }
    return buf.Bytes(), nil
}

用测试验证页面隔离

不要只断言“没有错误”，还要同时检查首页标记、后台标记和公共布局。下面的紧凑测试能发现两个页面误用了同一个 content 的问题：

func TestDerivedPagesAreIsolated(t *testing.T) {
    home := derive(`{{define "content"}}
{{.Message}}
{{end}}`)
    admin := derive(`{{define "content"}}
{{.Message}}
{{end}}`)

    var homeOut, adminOut bytes.Buffer
    // 分别执行两个副本，验证同名 content 没有跨集合污染。
    if err := home.ExecuteTemplate(&homeOut, "layout", ViewData{Title: "H", Message: "A"}); err != nil {
        t.Fatal(err)
    }
    if err := admin.ExecuteTemplate(&adminOut, "layout", ViewData{Title: "D", Message: "B"}); err != nil {
        t.Fatal(err)
    }
    if !strings.Contains(homeOut.String(), `id="home"`) || strings.Contains(homeOut.String(), `id="admin"`) {
        t.Fatalf("home template leaked: %s", homeOut.String())
    }
    if !strings.Contains(adminOut.String(), `id="admin"`) || strings.Contains(adminOut.String(), `id="home"`) {
        t.Fatalf("admin template leaked: %s", adminOut.String())
    }
}

常见问题

Clone 后修改副本会影响原模板吗？

不会。副本拥有自己的关联模板命名空间，后续在副本上解析页面定义不会加入原模板。但模板函数可能引用外部可变状态，那部分状态仍需由业务代码自行保证并发安全。

为什么要执行 layout，而不是直接执行 content？

layout 是完整页面入口，它负责页头、页脚以及调用当前集合里的 content。直接执行 content 只会得到页面主体。

可以每次请求都 Clone 吗？

不建议。公共模板一旦执行，后续克隆会失败；而且重复解析增加延迟。更合理的方式是启动时派生所有页面，运行期只查表并执行。