在Golang中使用pongo2template引擎

Gopongo2教程展示了如何使用pongo2template引擎在Golang中使用模板。

$ go version
go version go1.18.1 linux/amd64

我们使用Go版本1.18。

模板引擎是一个库，旨在将模板与数据相结合以生成文档。模板引擎用于生成大量电子邮件、源代码预处理或生成动态HTML页面。

模板由静态数据和动态区域组成。动态区域后来被数据替换。渲染功能随后将模板与数据结合起来。模板引擎用于将模板与数据模型相结合以生成文档。

pongo2库是一个受Django模板引擎启发的Go模板引擎。

pongo2在模板字符串中使用各种分隔符：

• {%%}-语句
• {{}}-打印到模板输出的表达式
• {##}-不包含在模板输出中的注释
• ###-行语句

可以使用pongo2.FromString从字符串、使用pongo2.FromFile的文件或使用pongo2.FromBytes的字节读取模板。

文档使用Execute、ExecuteWriter或ExecuteBytes函数呈现。这些函数接受一个Context，它向模板提供常量、变量、实例或函数。

去pongo2.FromString

pongo2.FromString从字符串中读取模板。

package main

import (
    "fmt"
    "log"

    "github.com/flosch/pongo2/v5"
)

func main() {

    tpl, err := pongo2.FromString("Hello {{ name }}!")

    if err != nil {
        log.Fatal(err)
    }

    res, err := tpl.Execute(pongo2.Context{"name": "John Doe"})

    if err != nil {
        log.Fatal(err)
    }

    fmt.Println(res)
}

该示例生成一条简单的文本消息。

tpl, err := pongo2.FromString("Hello {{ name }}!")

要打印的变量放在{{}}括号内。

res, err := tpl.Execute(pongo2.Context{"name": "John Doe"})

我们使用Execute呈现最终字符串。在上下文中，我们为name变量传递了一个值。

$ go run main.go
Hello John Doe!

package main

import (
    "fmt"
    "log"

    "github.com/flosch/pongo2/v5"
)

func main() {

    tpl, err := pongo2.FromString("{{ name }} is a {{ occupation }}")

    if err != nil {
        log.Fatal(err)
    }

    name, occupation := "John Doe", "gardener"
    ctx := pongo2.Context{"name": name, "occupation": occupation}

    res, err := tpl.Execute(ctx)

    if err != nil {
        log.Fatal(err)
    }

    fmt.Println(res)
}

在这个例子中，我们在上下文中传递了两个变量。

$ go run main.go
John Doe is a gardener

去pongo2.FromFile

使用pongo2.FromFile函数，我们从文件中读取模板。

{{ name }} is a {{ occupation }}

这是模板文件。

package main

import (
    "fmt"
    "log"

    "github.com/flosch/pongo2/v5"
)

func main() {

    tpl, err := pongo2.FromFile("message.tpl")

    if err != nil {
        log.Fatal(err)
    }

    name, occupation := "John Doe", "gardener"
    ctx := pongo2.Context{"name": name, "occupation": occupation}

    res, err := tpl.Execute(ctx)

    if err != nil {
        log.Fatal(err)
    }

    fmt.Println(res)
}

该示例在从文件读取模板时生成一条简单的消息。

去pongo2获取指令

for指令用于迭代模板中的数据集合。

{% for word in words -%}
    {{ word }}
{% endfor %}

在模板中，我们使用for指令遍历words数据结构的元素。-字符去除空白字符。

package main

import (
    "fmt"
    "log"

    "github.com/flosch/pongo2/v5"
)

func main() {

    tpl, err := pongo2.FromFile("words.tpl")

    if err != nil {
        log.Fatal(err)
    }

    words := []string{"sky", "blue", "storm", "nice", "barrack", "stone"}

    ctx := pongo2.Context{"words": words}

    res, err := tpl.Execute(ctx)

    if err != nil {
        log.Fatal(err)
    }

    fmt.Println(res)
}

在程序中，我们将一段单词传递给模板引擎。我们得到一个单词列表作为输出。

$ go run main.go
sky
blue
storm
nice
barrack
stone

去pongo2过滤器

过滤器可以应用于数据以修改它们。在|之后应用过滤器性格。

{% for word in words -%}
    {{ word }} has {{ word | length }} characters
{% endfor %}

length过滤器返回字符串的大小。

package main

import (
    "fmt"
    "log"

    "github.com/flosch/pongo2/v5"
)

func main() {

    tpl, err := pongo2.FromFile("words.tpl")

    if err != nil {
        log.Fatal(err)
    }

    words := []string{"sky", "blue", "storm", "nice", "barrack", "stone"}

    ctx := pongo2.Context{"words": words}

    res, err := tpl.Execute(ctx)

    if err != nil {
        log.Fatal(err)
    }

    fmt.Println(res)
}

在程序中，我们将一段单词传递给模板。我们打印每个单词及其大小。

$ go run main.go
sky has 3 characters
blue has 4 characters
storm has 5 characters
nice has 4 characters
barrack has 7 characters
stone has 5 characters

如果有条件就去pongo2

可以使用if/endif指令创建条件。

{% for todo in todos -%}
    {% if todo.Done %}
        {{- todo.Title -}}
    {% endif %}
{% endfor %}

在模板文件中，我们使用if指令只输出完成的任务。

package main

import (
    "fmt"
    "log"

    "github.com/flosch/pongo2/v5"
)

type Todo struct {
    Title string
    Done  bool
}

type Data struct {
    Todos []Todo
}

func main() {

    tpl, err := pongo2.FromFile("todos.tpl")

    if err != nil {
        log.Fatal(err)
    }

    todos := []Todo{
        {Title: "Task 1", Done: false},
        {Title: "Task 2", Done: true},
        {Title: "Task 3", Done: true},
        {Title: "Task 4", Done: false},
        {Title: "Task 5", Done: true},
    }

    ctx := pongo2.Context{"todos": todos}

    res, err := tpl.Execute(ctx)

    if err != nil {
        log.Fatal(err)
    }

    fmt.Println(res)
}

我们从一片待办事项中生成输出。在输出中，我们只包含已完成的任务。

服务器示例

在下一个示例中，我们在服务器应用程序中使用模板。

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Users</title>
</head>

<body>
    <table>
        <thead>
            <tr>
                <th>Name</th>
                <th>Occupation</th>
            </tr>
        </thead>
        <tbody>
            {% for user in users %}
            <tr>
                <td>{{ user.Name }} </td>
                <td>{{ user.Occupation }}</td>
            </tr>
            {% endfor %}
        </tbody>
    </table>
</body>
</html>

输出是一个HTML文件。用户显示在HTML表格中。

package main

import (
    "net/http"

    "github.com/flosch/pongo2/v5"
)

type User struct {
    Name       string
    Occupation string
}

var tpl = pongo2.Must(pongo2.FromFile("users.html"))

func usersHandler(w http.ResponseWriter, r *http.Request) {

    users := []User{
        {Name: "John Doe", Occupation: "gardener"},
        {Name: "Roger Roe", Occupation: "driver"},
        {Name: "Peter Smith", Occupation: "teacher"},
    }

    err := tpl.ExecuteWriter(pongo2.Context{"users": users}, w)

    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
    }
}

func main() {

    http.HandleFunc("/users", usersHandler)
    http.ListenAndServe(":8080", nil)
}

Web服务器返回一个HTML页面，其中包含/usersURL路径的用户表。

var tpl = pongo2.Must(pongo2.FromFile("index.html"))

pongo2.Must是一个辅助函数，它在应用程序启动时预编译模板。

err := tpl.ExecuteWriter(pongo2.Context{"users": users}, w)

ExecuteWriter使用给定的上下文呈现模板，并在成功时将输出写入响应编写器。没有写错；而是返回错误。

在本教程中，我们使用第三方pongo2模板引擎创建了动态文档。

列出所有Go教程。