Syntaxe du modèle de langage Go

Annuaire d'articles

<center> Syntaxe du modèle de langage Go

Les symboles reliant les extrémités avant et arrière :`{ {}}`

La syntaxe du modèle y est incluse { {}}, parmi laquelle { {.}}représente .l'objet courant. Lors du passage d'un objet de structure, vous pouvez accéder accéder à ses champs en"."aux champs correspondants de la structure. S'il s'agit de données de type composite, vous pouvez{ {.FiledName}}FiledName

Exemple de pseudo-code :

//在html文档中
<body>
	<p>Hello {
      
      {
      
      .Name}}</p>
	<p>Gender {
      
      {
      
      .Gemder}}</p>	
	<p>Age {
      
      {
      
      .Age}}</p>
</body>

//在Go代码中
type UserInfo struct{
      
      
    Name string
    Gender string
    Age int
}
user := &UserInfo{
      
      
    Name:"李四",
    Gender: "未知",
    Age: 24,
}

De cette façon, les données back-end sont transmises à l'affichage frontal

note

grammaire:{ {/*注释内容*/}}
Fonction : Conformément aux commentaires dans d'autres langues, le but est d'améliorer la lisibilité du code
Remarque : des commentaires multilignes peuvent être ajoutés, mais les commentaires imbriqués ne sont pas autorisés et doivent commencer et se terminer près du délimiteur

pipeline

introduire:Un pipeline est une opération qui produit des données, tels que "{ {.}}", "{ {.Name}}", etc., la grammaire du modèle de langage Go prend en charge l'utilisation du symbole de pipeline "|" pour lier plusieurs instructions, et l'utilisation est similaire à la pipeline sous UNIX, donc le pipeline est comme C'est un concept, il suffit de le savoir

variable

Introduction : Dans Action, une variable peut être initialisée pour capturer le résultat d'exécution du pipeline
- Action : dans le développement Web, Action fait généralement référence à un gestionnaire ou à une fonction qui gère les requêtes HTTP. Lorsqu'un utilisateur effectue une opération sur une page Web (comme cliquer sur un bouton, soumettre un formulaire), l'action correspondante sera appelée pour traiter la demande et effectuer les opérations logiques correspondantes.
grammaire:$variable := pipeline
Fonctionnalités : les actions qui déclarent des variables ne produiront aucune sortie, ce qui signifie à peu prèsLorsque la variable est uniquement déclarée sans l'affecter ou l'utiliser, la sortie du programme n'affichera pas la valeur de la variable ou d'autres informations. Ce n'est que lorsqu'une variable est affectée à une valeur et utilisée dans le programme qu'elle peut être vue dans la sortie.

jugement conditionnel

grammaire:
- { {if pipeline}} T1 { {end}}
- { {if pipeline}} T1 { {else}} T0 { {end}}
- { {if pipeline}} T1 { {else if pipeline}} T0 { {end}}

mot-clé de plage

Pour utiliser le mot-clé range dans Go, la valeur de pipeline doit être un tableau, une tranche, un dictionnaire ou un canal.
grammaire:
- { {range pipeline}} T1 { {end}}
- { {range pipeline}} T1 { {else}} T0 { {end}}

avec mot clé

Le mot-clé with est quelque peu similaire au mot-clé if, l' opération "{ {with}}" n'exécute conditionnellement son corps que lorsque le pipeline passé n'est pas vide
grammaire:
- { {with pipeline}} T1 { {end}}
- { {with pipeline}} T1 { {else}} T0 { {end}}

fonction de comparaison

symbole	effet
`eq`	==
`ne`	!=
`lt`	<
`le`	<=
`gt`	>
`ge`	>=

Caractéristiques : Seuls eqles symboles peuvent recevoir plusieurs paramètres, il comparera le premier paramètre avec le reste des paramètres à la fois
exemple:{ {eq arg1 arg2 arg3}} ==> arg1== arg2||arg1 == arg3

fonction personnalisée

Il existe des fonctions prédéfinies (définies officiellement) et des fonctions personnalisées (définies par vous-même) dans les modèles imbriqués. Les fonctions personnalisées rendent les modèles plus flexibles.
Les fonctions personnalisées Funcs()sont implémentées en appelant des méthodes
- Funcs()Définition de la méthode :func (t *Template) Funcs(funcMap FuncMap) *Template
- FuncMapddéfinition:type FuncMap map[string]interface{}
Étapes de définition :
- 1. Définissez d'abord une fonction dans le code backend : (Fonction anonyme à titre d'exemple)
  - ```
  hello := func() (string){
            
            
      return "Hello!"
  }
```
- 2. Funcs()Méthode d'appel
  - Remarque : Pour appeler Funcs()une méthode, elle doit être appelée avant d'analyser le modèle, c'est-à-dire Parse()avant la méthode
  - ```
  bytes,err := ioutil.ReadFile("文件名/文件路径") 
  templl,err := template.New("为模板命名(尽量和文件名字一致)").Funcs(template.FuncMap{
            
            "hello":hello}).Parse(string(bytes))
```
- 1. Appelez la fonction dans le modèle :
  - { {hello}}
  - Ici helloest spécifié FuncMap, keyc'est-à-dire ce qui précède"hello"

modèles imbriqués

Introduction : Modèles imbriqués, c'est-à-dire, en utilisant plusieurs modèles dans un fichier html, le modèle imbriqué peut être un htmlfichier séparé, et defineun modèle peut également être défini sous le modèle à l'aide de mots-clés
- defineSyntaxe : { {define "name"}} T(content) { {end}}
templateExécuter des modèles par mots-clés
- grammaire:
  - { {template "name"}}
  - { {template "name" pipeline}}

Exemple : (code du modèle)Demo.html

<html>
	<body>
    	<h1>{
       
       {template "title.html"}}</h1>
        <div>
            {
       
       {template "content.html"}}
        </div>
	</body>
</html>
{
       
       {/*define 的定义写在html标签之下*/}}
{
       
       {define "content.html"}}
	<li>小明</li>
	<li>小红</li>
{
       
       {end}}

title.htmldéfinition de fichier
- ```
<ul>
    <il>你好</il>
</ul>
```

Code backend (principal) :
- ```
tmpl,err :=template.ParseFiles("Demo.html路径","title.html路径")
```
- Lors de l'analyse du code, vous devez écrire des fichiers contenant d'autres modèles dansLe premier, et le reste peut être dans un ordre aléatoire

Code similaire connexe :

fichier hello.html
- ```
<p>大家好,我是小黑子</p>
```

Fichier serveur.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>嵌套模板</title>
</head>
<body>
    {
         
         {/*自定义函数加模板嵌套*/}}
    <h1>{
         
         {Hello}}</h1>
    <hr>
    <h2>{
         
         {template "hello.html"}}</h2>
    <p>{
         
         {.}}真帅!</p>
    <hr>
    {
         
         {template "come.html"}}
</body>
</html>
{
         
         {define "come.html"}}
<ul>
    <li>唱</li>
    <li>跳</li>
    <li>rap</li>
    <li>篮球</li>
</ul>
{
         
         {end}}

Code principal :

package main

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

func main() {
          
          
	http.HandleFunc("/", hello)
	http.ListenAndServe(":9000", nil)
}

func hello(w http.ResponseWriter, r *http.Request) {
          
          
	//定义模板
	//解析模板,自定义函数
	Hello := func() string {
          
          
		return "--- 欢迎来到我的舞台 ---"
	}

	tmpl, err := template.New("Sever.html").Funcs(template.FuncMap{
          
          "Hello": Hello}).ParseFiles(
		"src\\使用html和template包\\Go语言模板语法\\嵌套模板\\Sever.html",
		"src\\使用html和template包\\Go语言模板语法\\嵌套模板\\hello.html")
	if err != nil {
          
          
		log.Println("解析模板失败!")
		return
	}
	name := "贤哥"
	//渲染模板
	err = tmpl.Execute(w, name)
	if err != nil {
          
          
		log.Println("渲染模板失败!:", err)
	}
}

Cela inclut l'utilisation de fonctions personnalisées, de modèles imbriqués et de valeurs de transmission

héritage de modèle

Introduction : L'héritage de modèle fait référence à la réutilisation de diverses sections fixes similaires. Par exemple, lorsque nous développons des sites Web, de nombreux endroits dans différentes pages Web sont similaires, de sorte que l'héritage de modèle peut être utilisé pour réutiliser des modèles. Réduisez la charge de travail et le code est plus concis
mots clésblock
- grammaire:{ {block "name" pipeline}} T { {end}}
Pour les modèles qui doivent être hérités, vous devez d'abord hériter du modèle racine, puis utiliser le mot-clé define pour définir le contenu

exemple

base.tmpdocument

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>模板继承</title>
</head>
<style>
    *{
          
          
        background-color:white;
    }
</style>
<body>
<h1  style="color:red">模板继承</h1>
<hr>
<h2  style="color:blue">变化的内容:</h2>
<div>{
       
       {block "context" .}}
        <p>会发生变化的地方</p>
        <div>
            <a href="http://localhost:9000/index">Index页面</a><br>
            <a href="http://localhost:9000/home">Home页面</a>
        </div>
    {
       
       {end}}</div>
</body>
</html>

Cela implique un peu de csscontenu et n'affecte pas la lecture

index.tmpldocument

{
       
       {/*继承根模板*/}}
{
       
       {template "base.tmpl" .}}
{
       
       {/*定义块模板*/}}
{
       
       {define "context"}}
<h2>Index页面</h2>
<p>Hello,{
       
       {.}}</p>
<a href="http://localhost:9000">Base页面</a>
{
       
       {end}}

Commencez par hériter puis définissez le contenu, où { {template "base.tmpl" .}}"." fait référence à la valeur transmise et <p>Hello,{ {.}}</p>"." reçoit la valeur
De plus, le nom de fichier après la définition ici doit être cohérent avec le nom défini dans le bloc

home.tmpldocument

{
       
       {/*继承根模板*/}}
{
       
       {template "base.tmpl" .}}
{
       
       {/*定义块模板*/}}
{
       
       {define "context"}}
    <h2>Home页面</h2>
    <p>Hello,{
       
       {.}}</p>
    <a href="http://localhost:9000">Base页面</a>
{
       
       {end}}

Fondamentalement le même que ci-dessus

code principal

package main

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

func main() {
        
        
	http.HandleFunc("/", base)
	http.HandleFunc("/index", index)
	http.HandleFunc("/home", home)
	err := http.ListenAndServe(":9000", nil)
	if err != nil {
        
        
		log.Println(err)
		return
	}
}

func base(w http.ResponseWriter, r *http.Request) {
        
        
	//定义模板
	//解析模板
	t, err := template.New("base.tmpl").ParseFiles("src\\使用html和template包\\Go语言模板语法\\模板继承\\base.tmpl")
	if err != nil {
        
        
		log.Println("解析失败:", err)
		return
	}
	//渲染模板
	err = t.Execute(w, nil)
	if err != nil {
        
        
		log.Println("渲染失败:", err)
		return
	}
}

func index(w http.ResponseWriter, r *http.Request) {
        
        
	//定义模板
	//解析模板(涉及嵌套模板)
	t, err := template.New("base.tmpl").ParseFiles("src\\使用html和template包\\Go语言模板语法\\模板继承\\base.tmpl",
		"src\\使用html和template包\\Go语言模板语法\\模板继承\\index.tmpl")
	if err != nil {
        
        
		log.Println("解析失败:", err)
		return
	}
	name := "贤哥!"
	//渲染模板
	err = t.ExecuteTemplate(w, "index.tmpl", name)
	if err != nil {
        
        
		log.Println("渲染失败:", err)
		return
	}
}
func home(w http.ResponseWriter, r *http.Request) {
        
        
	//定义模板
	//解析模板
	t, err := template.New("base.tmpl").ParseFiles("src\\使用html和template包\\Go语言模板语法\\模板继承\\base.tmpl",
		"src\\使用html和template包\\Go语言模板语法\\模板继承\\home.tmpl")
	if err != nil {
        
        
		log.Println("解析失败:", err)
		return
	}
	name := "振哥!"
	//渲染模板
	err = t.ExecuteTemplate(w, "home.tmpl", name)
	if err != nil {
        
        
		log.Println("渲染失败:", err)
		return
	}
}

Syntaxe du modèle de langage Go

Syntaxe du modèle de langage Go

Annuaire d'articles

Les symboles reliant les extrémités avant et arrière :{ {}}

note

pipeline

variable

jugement conditionnel

mot-clé de plage

avec mot clé

fonction de comparaison

fonction personnalisée

modèles imbriqués

héritage de modèle

Je suppose que tu aimes

Les symboles reliant les extrémités avant et arrière :`{ {}}`