登录
当前位置： 首页 > 工具软件 > Go template > 使用案例 >

Golang — template

廉学潞
2023-12-01

Go语言模板引擎

Go语言内置了文本模板引擎text/template和用于HTML文档的html/template。

它们的作用机制可以简单归纳如下：

  • 模板文件通常定义为.tmpl和.tpl为后缀（也可以使用其他的后缀），必须使用UTF8编码。
  • 模板文件中使用{{和}}包裹和标识需要传入的数据。
  • 传给模板的数据可以通过点号.来访问，如果数据是复杂类型的数据，可以通过{{ .FieldName }}来访问它的字段。
  • 除{{和}}包裹的内容外，其他内容均不做修改原样输出。

模板语法

{{和}}包裹的内容统称为 action，分为两种类型：

  • 数据求值（data evaluations）
  • 控制结构（control structures）

action 求值的结果会直接复制到模板中，控制结构和我们写 Go 程序差不多，也是条件语句、循环语句、变量、函数调用等等…

1. 注释

{{/* a comment */}}
// 注释，执行时会忽略。可以多行。注释不能嵌套，并且必须紧贴分界符始止。

2. 移除空格

在{{符号的后面加上短横线并保留一个或多个空格来去除它前面的空白(包括换行符、制表符、空格等)，即{{- xxxx。

在}}的前面加上一个或多个空格以及一个短横线-来去除它后面的空白，即xxxx -}}。

<p>{{ 20 }} < {{ 40 }}</p> // 20 < 40
<p>{{ 20 -}} < {{- 40 }}</p> // 20<40

3. 管道pipeline

pipeline是指产生数据的操作。比如{{.}}、{{.Name}}、funcname args等。

可以使用管道符号|链接多个命令，用法和unix下的管道类似：|前面的命令将运算结果(或返回值)传递给后一个命令的最后一个位置。

{{"put" | printf "%s%s" "out" | printf "%q"}}  // "output"

4. 变量

在golang渲染template的时候，可以接受一个interface{}类型的变量，我们在模板文件中可以读取变量内的值并渲染到模板里。

{{和}}中间的 . 代表传入的变量（数据），其代表当前作用域的当前对象，变量（数据）不同渲染不同。

有两个常用的传入变量的类型。一个是struct，在模板内可以读取该struct的字段（对外暴露的属性）来进行渲染。还有一个是map[string]interface{}，在模板内可以使用key获取对应的value来进行渲染。

示例代码：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
   <p>姓名：{{ .Name }}</p> 
   <p>年龄：{{ .Age }}</p>
   <p>性别：{{ .Gender }}</p>
   <p>语文成绩：{{ .Score.yuwen}}</p>
   <p>数学成绩：{{ .Score.shuxue}}</p>
   <p>英语成绩：{{ .Score.yingyu}}</p>
</body>
</html>

package main

import (
    "fmt"
    "html/template"
    "net/http"
)

// User 结构体
type User struct {
    Name   string
    Age    int
    Gender string
    Score  map[string]float64
}

func indexHandleFunc(w http.ResponseWriter, r *http.Request) {
    t, err := template.ParseFiles("./index.tmpl")
    if err != nil {
        fmt.Println("template parsefiles failed, err:", err)
        return
    }
    user := User{
        Name:   "ruby",
        Age:    20,
        Gender: "female",
        Score: map[string]float64{
            "yuwen":  98,
            "shuxue": 100,
            "yingyu": 94,
        },
    }
    t.Execute(w, user)
}

func main() {
    http.HandleFunc("/", indexHandleFunc)
    http.ListenAndServe(":8080", nil)
}

自定义变量

{{ $obj := "jack" }}
{{ $obj }} // 输出：jack

5. 函数

golang的模板其实功能很有限，很多复杂的逻辑无法直接使用模板语法来表达，所以只能使用模板函数来实现。

首先，template包创建新的模板的时候，支持.Funcs方法来将自定义的函数集合导入到该模板中，后续通过该模板渲染的文件均支持直接调用这些函数。

该函数集合的定义为：

type FuncMap map[string]interface{}

key为方法的名字，value则为函数。这里函数的参数个数没有限制，但是对于返回值有所限制。有两种选择，一种是只有一个返回值，还有一种是有两个返回值，但是第二个返回值必须是error类型的。这两种函数的区别是第二个函数在模板中被调用的时候，假设模板函数的第二个参数的返回不为空，则该渲染步骤将会被打断并报错。

内置模板函数：

var builtins = FuncMap{
    // 返回第一个为空的参数或最后一个参数。可以有任意多个参数。
    // "and x y"等价于"if x then y else x"
    "and": and,
    // 显式调用函数。第一个参数必须是函数类型，且不是template中的函数，而是外部函数。
    // 例如一个struct中的某个字段是func类型的。
    // "call .X.Y 1 2"表示调用dot.X.Y(1, 2)，Y必须是func类型，函数参数是1和2。
    // 函数必须只能有一个或2个返回值，如果有第二个返回值，则必须为error类型。
    "call": call,
    // 返回与其参数的文本表示形式等效的转义HTML。
    // 这个函数在html/template中不可用。
    "html": HTMLEscaper,
    // 对可索引对象进行索引取值。第一个参数是索引对象，后面的参数是索引位。
    // "index x 1 2 3"代表的是x[1][2][3]。
    // 可索引对象包括map、slice、array。
    "index": index,
    // 返回与其参数的文本表示形式等效的转义JavaScript。
    "js": JSEscaper,
    // 返回参数的length。
    "len": length,
    // 布尔取反。只能一个参数。
    "not": not,
    // 返回第一个不为空的参数或最后一个参数。可以有任意多个参数。
    // "or x y"等价于"if x then x else y"。
    "or":      or,
    "print":   fmt.Sprint,
    "printf":  fmt.Sprintf,
    "println": fmt.Sprintln,
    // 以适合嵌入到网址查询中的形式返回其参数的文本表示的转义值。
    // 这个函数在html/template中不可用。
    "urlquery": URLQueryEscaper,
}

比较函数：

eq arg1 arg2：
    arg1 == arg2时为true
ne arg1 arg2：
    arg1 != arg2时为true
lt arg1 arg2：
    arg1 < arg2时为true
le arg1 arg2：
    arg1 <= arg2时为true
gt arg1 arg2：
    arg1 > arg2时为true
ge arg1 arg2：
    arg1 >= arg2时为true

自定义模板函数

t = t.Funcs(template.FuncMap{"handleFieldName": HandleFunc})

函数调用

{{funcname .arg1 .arg2}}

6. 条件判断

{{ if pipeline }} T1 {{ end }}
{{ if pipeline }} T1 {{ else }} T2 {{ end }}
{{ if pipeline }} T1 {{ else if pipeline }} T2 {{ end }}

7. 循环遍历

{{ range pipeline }} T1 {{ end }}
// 如果 pipeline 的长度为 0 则输出 else 中的内容
{{ range pipeline }} T1 {{ else }} T2 {{ end }}

range可以遍历slice、数组、map或channel。遍历的时候，会设置.为当前正在遍历的元素。

对于第一个表达式，当遍历对象的值为0值时，则range直接跳过，就像if一样。对于第二个表达式，则在遍历到0值时执行else。

range的参数部分是pipeline，所以在迭代的过程中是可以进行赋值的。但有两种赋值情况：

{{ range $value := pipeline }} T1 {{ end }}
{{ range $key, $value := pipeline }} T1 {{ end }}

如果range中只赋值给一个变量，则这个变量是当前正在遍历元素的值。如果赋值给两个变量，则第一个变量是索引值(array/slice是数值，map是key)，第二个变量是当前正在遍历元素的值。

8. with…end

{{ with pipeline }} T1 {{ end }}
{{ with pipeline }} T1 {{ else }} T0 {{ end }}

对于第一种格式，当pipeline不为0值的时候，将.设置为pipeline运算的值，否则跳过。
对于第二种格式，当pipeline为0值时，执行else语句块T0，否则.设置为pipeline运算的值，并执行T1。

9. 模板嵌套

  • define
    define可以直接在待解析内容中定义一个模板

    // 定义名称为name的template
{{ define "name" }} T {{ end }}

  • template
    使用template来执行模板

    // 执行名为name的template
{{ template "name" }}
{{ template "name"  pipeline }}

  • block

    {{ block "name" pipeline }} T {{ end }}

    block等价于define定义一个名为name的模板，并在"有需要"的地方执行这个模板，执行时将.设置为pipeline的值。

    等价于：先 {{ define “name” }} T {{ end }} 再执行 {{ template “name” pipeline }}。

代码示例：

<!-- index.tmpl -->
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
   {{ template "content"}} 
</body>
</html>

<!-- red.tmpl -->
{{ define "content" }} 
    <div style="color:red"><h3>hello world</h3></div>
{{ end }}

<!-- blue.tmpl -->
{{ define "content" }} 
    <div style="color:blue"><h3>hello world</h3></div>
{{ end }}

// main.go
package main

import (
    "html/template"
    "math/rand"
    "net/http"
    "time"
)

func indexHandleFunc(w http.ResponseWriter, r *http.Request) {
    t := template.New("index.tmpl")
    rand.Seed(time.Now().UnixNano())
    if rand.Intn(100) > 50 {
        t, _ = template.ParseFiles("./index.tmpl", "./red.tmpl")
    } else {
        t, _ = template.ParseFiles("./index.tmpl", "./blue.tmpl")
    }
    t.Execute(w, "")
}
func main() {
    http.HandleFunc("/", indexHandleFunc)
    http.ListenAndServe(":8080", nil)
}

如果使用block，那么可以设置默认的content模板。
修改index.tmpl

<!-- index.tmpl -->
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    {{ block "content" . }}
    <div style="color:yellow"><h3>hello world</h3></div>
    {{ end }}
</body>
</html>

修改后端程序：

// main.go
package main

import (
    "html/template"
    "math/rand"
    "net/http"
    "time"
)

func indexHandleFunc(w http.ResponseWriter, r *http.Request) {
    t := template.New("index.tmpl")
    rand.Seed(time.Now().UnixNano())
    if rand.Intn(100) > 75 {
        t, _ = template.ParseFiles("./index.tmpl", "./red.tmpl")
    } else if rand.Intn(100) > 25 {
        t, _ = template.ParseFiles("./index.tmpl", "./blue.tmpl")
    } else {
        t, _ = template.ParseFiles("./index.tmpl")
    }
    t.Execute(w, "")
}
func main() {
    http.HandleFunc("/", indexHandleFunc)
    http.ListenAndServe(":8080", nil)
}

10. 模板继承

通过block、define、template实现模板继承。

示例代码：

<!-- base.tmpl -->
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <style>
        .head {
            height: 50px;
            background-color: red;
            width: 100%;
            text-align: center;
        }
        .main {
            width: 100%;
        }
        .main .left {
            width: 30%;
            height: 1000px;
            float: left;
            background-color:violet;
            text-align: center;
        }
        .main .right {
            width: 70%;
            float: left;
            text-align: center;
            height: 1000px;
            background-color:yellowgreen;
        }
    </style>
</head>
<body>
    <div class="head">
        <h1>head</h1>
    </div> 
    <div class="main">
        <div class="left">
        <h1>side</h1>
        </div>
        <div class="right">
            {{ block "content" . }}
            <h1>content</h1>
            {{ end }}
        </div>
    </div>
</body>
</html>

<!-- index.tmpl -->
{{ template "base.tmpl" . }}

{{ define "content" }}
<h1>这是index页面</h1>
{{ . }}
{{ end }}

<!-- home.tmpl -->
{{ template "base.tmpl" . }}

{{ define "content" }}
<h1>这是home页面</h1>
{{ . }}
{{ end }}

// main.go
package main

import (
    "html/template"
    "net/http"
)

func indexHandleFunc(w http.ResponseWriter, r *http.Request) {
    t := template.New("index.tmpl")
    t, _ = t.ParseFiles("./base.tmpl", "./index.tmpl")
    t.Execute(w, "index")
}

func homeHandleFunc(w http.ResponseWriter, r *http.Request) {
    t := template.New("home.tmpl")
    t, _ = t.ParseFiles("./base.tmpl", "./home.tmpl")
    t.Execute(w, "home")
}

func main() {
    server := http.Server{
        Addr: "localhost:8080",
    }
    http.HandleFunc("/index", indexHandleFunc)
    http.HandleFunc("/home", homeHandleFunc)
    server.ListenAndServe()
}

11. 修改默认的标识符

Go标准库的模板引擎使用的花括号{{和}}作为标识，而许多前端框架（如Vue和 AngularJS）也使用{{和}}作为标识符，所以当我们同时使用Go语言模板引擎和以上前端框架时就会出现冲突，这个时候我们需要修改标识符，修改前端的或者修改Go语言的。这里演示如何修改Go语言模板引擎默认的标识符：

template.New("test").Delims("{[", "]}").ParseFiles("./t.tmpl")

12. html/template的上下文感知

对于html/template包，有一个很好用的功能：上下文感知。text/template没有该功能。

上下文感知具体指的是根据所处环境css、js、html、url的path、url的query，自动进行不同格式的转义。

示例代码

<!-- index.tmpl -->
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    <div>{{ . }}</div>
</body>
</html>

// main.go
package main

import (
    // "text/template"
    "html/template"
    "net/http"
)

func indexHandleFunc(w http.ResponseWriter, r *http.Request) {
    t, _ := template.ParseFiles("./index.tmpl")
    data := `<script>alert("helloworld")</script>`
    t.Execute(w, data)
}

func main() {
    http.HandleFunc("/", indexHandleFunc)
    http.ListenAndServe(":8080", nil)
}

运行程序，页面显示：

<script>alert("helloworld")</script>

不转义

上下文感知的自动转义能让程序更加安全，比如防止XSS攻击(例如在表单中输入带有的内容并提交，会使得用户提交的这部分script被执行)。

如果确实不想转义，可以进行类型转换。

type CSS
type HTML
type JS
type URL

编写一个自定义的模板函数，实现对内容的类型转换。

示例代码：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    <div>{{ .str1 }}</div>
    <div>{{ .str2 | safe }}</div>
</body>
</html>

package main

import (
    // "text/template"
    "html/template"
    "net/http"
)

func indexHandleFunc(w http.ResponseWriter, r *http.Request) {
    t := template.New("index.tmpl")
    t.Funcs(template.FuncMap{
        "safe": func(str string) template.HTML {
            return template.HTML(str)
        },
    }).ParseFiles("./index.tmpl")
    m := map[string]interface{}{
        "str1": `<script>alert("helloworld")</script>`,
        "str2": `<a href = "http://baidu.com">baidu</a>`,
    }
    t.Execute(w, m)
}

参考文档：
【go语言学习】标准库之template

 类似资料：

相关阅读

Golang mgo查找如何卸载Golang？Gorm Golang Orm协会Golang延迟行为Golang类型断言

相关文章

golang 管培笔试小米golang一面得物 golang 一面高途Golang 一面golang社招面经

相关问答

Golang恐慌防撞车Golang API编码问题Golang：保护源代码golang window程序崩溃?golang 如何使用fastwalk？

相关文档

Hprose for Golang 用户手册Go/Golang Echo v2 框架中文文档Art-template 中文文档C++ Template 进阶指南（未完）
快捷导航： 新手教程 算法原理 架构设计 Java进阶 数据库进阶 大厂专栏 面试经验 编程笔记 编程问答 所有专题 文档资料 工具软件 电子书籍 小牛导航
在线工具： 房贷计算器 个税计算器 Linux命令查询 Json格式化 正则表达式 颜色转换 AES加解密 SHA1加密 MD5加密 毒鸡汤 字数统计 随机密码生成 进制转换 Base64编解码 励志句子
Copyright © 2019-2024 小牛知识库@xnip.cn. All Rights Reserved.