Comment personnaliser les fonctions du modèle dans le framework gin.
Dans le framework gin, nous pouvons utiliser le module html/template fourni avec le langage Go pour le rendu des modèles.
Le module html/template fournit une série de fonctions intégrées, telles que eq, ne et, ou, etc., mais nous devons parfois personnaliser certaines fonctions pour répondre à nos besoins, comme le calcul de la valeur MD5 d'une chaîne.
Nous pouvons enregistrer des fonctions personnalisées dans le moteur de modèles via la méthode SetFuncMap afin qu'elles puissent être utilisées dans les modèles. Cette méthode reçoit un paramètre de type FuncMap, qui est une table de mappage dans laquelle la clé est le nom de la fonction personnalisée et la valeur est la fonction personnalisée elle-même. De cette façon, nous pouvons appeler des fonctions personnalisées via le nom de la fonction dans le modèle pour réaliser certaines fonctions spéciales.
Les scénarios d'utilisation des fonctions de modèle personnalisé sont très larges. Par exemple, nous pouvons définir une fonction qui formate l'heure, convertit l'horodatage dans un format lisible par l'homme ou définit une fonction qui calcule la longueur d'une chaîne pour nous aider à ajouter des caractères. dans le modèle.Opérations sur les chaînes, etc.
Voyons comment personnaliser les fonctions des modèles dans le framework gin. Partageons deux cas. L'un est celui que j'ai utilisé dans mon étude et l'autre est un cas que j'ai vu en ligne ;
Cas 1 : Définir une fonction qui formate l'heure
Défini dans le fichier d'entrée principal main.go, une fonction de modèle personnalisé est requise ;
package main
import (
"github.com/gin-gonic/gin"
"html/template"
"net/http"
"time"
)
// 定一个函数，这里就是我们自定义的函数了
func UnitTime(timestamp int) string {
t := time.Unix(int64(timestamp), 0)
return t.Format("2006-01-02 15:09:01")
}
func main() {
// 定义一个路由引擎
r := gin.Default()
//自定义函数 渲染 注入模版 使用 router.SetFuncMap(template.FuncMap{}) 这个里面用到的包"html/template"，就是一个第三方自定义函数包名称，负责渲染模版函数template到html内；
r.SetFuncMap(template.FuncMap{
"UnitTime": UnitTime,
})
// 加载 渲染模版
r.LoadHTMLGlob("*templates/**/*")
// 创建 路由
r.GET("/", func(ctx *gin.Context) {
new := &Article{
Title: "admin/index",
Content: "这是一个首页后台管理",
}
ctx.HTML(http.StatusOK, "default/index.html", gin.H{
"title": "首页",
"msg": "lll",
"news": new,
"score": 100,
"list": []string{"吃饭", "睡觉", "写代码"}, // 数组
"scoreList": []interface{}{
&Article{
Title: "新闻一",
Content: "新闻内容11111",
},
&Article{
Title: "新闻二",
Content: "新闻内容2222",
},
},
"data": 1686593382, //时间戳
})
})
//启动服务
r.Run(":8001")
}
En même temps, nous devons l'utiliser dans le modèle templates/default/index.html. Voici le code d'utilisation html :
{
{ define "default/index.html" }}
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>default/index.html</title>
<link rel="stylesheet" href="/static/css/index.css">
</head>
<body>
<h2>实际开发常用函数，自定义函数 </h2>
<p>
{
{UnitTime .data }}
</p>
<p style="font-size:14px;color: red;">{
{.data | UnitTime}}</p>
</body>
</html>
{
{end}}Remarque⚠️Le package " html/template " ici, " html/template " est un package de la bibliothèque standard du langage Go, utilisé pour générer des pages HTML. Il fournit un moyen sécurisé de restituer des données dynamiques, en évitant les vulnérabilités XSS (cross-site scripting) courantes. Dans un modèle, vous pouvez utiliser des variables, des structures de contrôle, des fonctions, etc. pour organiser la structure et le contenu de la page.
Remarque : "html/template" est un package de la bibliothèque standard du langage Go, utilisé pour générer des pages HTML. Il fournit un moyen sécurisé de restituer des données dynamiques, en évitant les vulnérabilités XSS (cross-site scripting) courantes. Dans un modèle, vous pouvez utiliser des variables, des structures de contrôle, des fonctions, etc. pour organiser la structure et le contenu de la page. Dans le même temps, « html/template » prend également en charge des fonctionnalités avancées telles que l'héritage de modèles, les modèles partiels et les pipelines, qui peuvent nous aider à créer plus facilement des pages HTML complexes.
Cas 2 : Définir une fonction de chiffrement
Tout d'abord, créez un fichier nommé funcMap.go dans notre projet pour stocker nos fonctions de modèle personnalisées. Le code est le suivant :
package main
import (
"crypto/md5"
"encoding/hex"
"html/template"
)
// 定义一个计算字符串MD5值的函数
func md5V(str string) string {
h := md5.New()
h.Write([]byte(str))
return hex.EncodeToString(h.Sum(nil))
}
// 初始化自定义函数
func InitFuncMap() template.FuncMap {
funcMap := template.FuncMap{
"md5": md5V,
}
return funcMap
}Dans le code ci-dessus, nous définissons une fonction nommée md5V pour calculer la valeur MD5 d'une chaîne. Ensuite, nous initialisons notre fonction personnalisée md5 via la fonction
InitFuncMap et la plaçons dans template.FuncMap.
Ensuite, utilisez la fonction personnalisée dans notre fichier modèle, le code est le suivant :
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>{
{.Title}}</title>
</head>
<body>
<p>{
{.Content}}</p>
<p>计算md5值：{
{md5 .Content}}</p>
</body>
</html>Si nous voulons utiliser des fonctions personnalisées dans les modèles, nous devons enregistrer ces fonctions dans le FuncMap du package "html/template". Normalement, nous stockons les fonctions et modèles personnalisés dans différents fichiers, puis les chargeons lors de l'initialisation du programme.
Bien sûr, il existe plusieurs méthodes : les deux méthodes ci-dessus peuvent être utilisées et vous pouvez choisir en fonction de vos préférences personnelles.
En même temps, je voudrais ajouter un supplément au deuxième scénario et expliquer une autre implémentation spécifique utilisée dans ce scénario.
Supposons que nous ayons un fichier nommé « funcs.go » dans le projet, qui définit une fonction personnalisée nommée « double » :
package main
import (
"html/template"
)
// 自定义函数，将传入的整数翻倍
func double(x int) int {
return x * 2
}
// 初始化模板，注册自定义函数
var tmpl = template.Must(template.New("").Funcs(template.FuncMap{
"double": double,
}).ParseFiles("template.html"))
// 渲染模板
func renderTemplate(data interface{}) error {
err := tmpl.ExecuteTemplate(os.Stdout, "template.html", data)
if err != nil {
return err
}
return nil
}Dans le code ci-dessus, nous enregistrons la fonction " double " dans le FuncMap du package " html/template " et initialisons le modèle à l'aide de la fonction " template.Must ". Dans le fichier modèle " template.html " on peut utiliser la fonction " double " comme ceci :
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>My Template</title>
</head>
<body>
<p>{
{ double . }}</p>
</body>
</html>Dans le modèle ci-dessus, nous utilisons le point « . » pour représenter l'objet de données actuel , puis appelons la fonction personnalisée via « double ». Lorsque nous appelons la fonction " renderTemplate ", l'objet de données est transmis au modèle pour le rendu et le résultat est affiché.
J'espère que cela pourra vous aider et donner un like au blogueur ! ! !