Lorsque vous créez un site Web, vous générez généralement une partie de votre contenu final de manière dynamique. Vous voudrez ensuite injecter ces données dans vos pages Web finales pour les afficher dans un navigateur.

Vous pouvez adopter l'une des deux approches suivantes: intégrer la structure de votre page dans votre programme ou combiner vos données finales avec des fichiers de modèle distincts.

Les modèles permettent de séparer les préoccupations pour une base de code plus maintenable. Cela facilite également la séparation des tâches frontales et des tâches principales, en les attribuant à différents membres de l'équipe. Go dispose d'un excellent support de modèles dans sa bibliothèque standard.

Premiers pas avec la création de modèles dans Go

Go a deux packages de modèles dans la bibliothèque standard: texte/modèle et html/modèle. Le package text/template a une fonctionnalité pour analyser les fichiers texte, tandis que html/template gère le HTML. En utilisant le html/template, vous êtes protégé contre les attaques de script intersite (XSS) puisque Go échappe à la saisie de données pendant le rendu. C'est un autre avantage des modèles par rapport à une approche manuelle.

instagram viewer

Étant donné que le package de modèle fait partie de la bibliothèque standard, vous n'aurez pas besoin d'installer de dépendances; il suffit de l'importer :

importer "html/modèle"

Commence par création d'un fichier HTML à utiliser comme modèle pour votre candidature. Vous pouvez utiliser la norme .html prolongation ou soit .gohtml ou .tmpl, les deux sont également communs. Quelle que soit l'extension que vous utilisez, les fonctionnalités de votre application seront les mêmes. Certains éditeurs de texte peuvent appliquer une coloration syntaxique différente selon les extensions de vos modèles. Voici un squelette de base :

<!DOCTYPE html>
<html lang="fr">
<tête>
<meta charset="UTF-8">
<Titre>Document</title>
</head>
<corps>
</body>
</html>

Enregistrez ce fichier dans le répertoire de votre programme Go. Vous pouvez maintenant commencer à l'utiliser, en tant que modèle, dans votre programme.

Créer une instance globale du Modèle méthode du package de modèle. Vous accéderez à cette instance de modèle à partir de différentes parties de votre programme.

var tmplt *modèle. Modèle

Vous devrez créer un serveur simple pour rendre et afficher vos modèles. Voici comment démarrer un serveur simple dans Go en utilisant le réseau/http forfait:

fonctionrunServer() {
 http. HandleFunc("/home", handlePage)
 euh := http. EcouteEtServe("localhost :8080", néant)
si erreur != néant {
 Journal. Fatalln("Il y a une erreur avec le serveur :", err)
 }
}

Vous appellerez le runServer fonction de votre fonction principale pour démarrer le serveur. Le serveur n'a qu'une seule route, la /home route, qui affichera votre page. La handlePage Le paramètre est le nom d'une fonction de gestionnaire qui affichera votre page. La ÉcouterEtServir la méthode démarre le serveur à l'écoute sur le port 8080 sur localhost, c'est-à-dire votre propre ordinateur.

Passer des variables aux modèles

Créez une structure globale nommée Nouvelles:

taper Nouvelles structure {
 Gros titre chaîne de caractères
 Corps chaîne de caractères
}

Vous utiliserez cette structure pour stocker des données et les transmettre à votre modèle pour les afficher sur votre page finale. Dans votre modèle, vous pouvez ensuite utiliser cette syntaxe pour injecter des données :

{{ Nom }}

Où Nom est le nom d'une variable que vous avez transmise à votre modèle. Lorsque vous affichez le modèle, il remplace les valeurs entre accolades par les données correspondantes de votre code Go. Étant donné que l'exemple suivant transmettra une structure, vous utiliserez la notation par points pour accéder à ses champs :

<corps>
<h1>{{ .Gros titre }}</h1>
<p> {{ .Corps }} </p>
</body>

Remplacez l'élément de corps vide dans le balisage squelette de votre modèle par le code ci-dessus.

La handlePage La fonction de gestionnaire vérifiera que la demande de la page est une demande GET. Il remplit ensuite une structure avec des exemples de données avant de rendre le modèle et de servir la page finale :

fonctionhandlePage(écrivain http. ResponseWriter, demande *http. Demande) {
si demande. Méthode == "OBTENIR" {
 tmplt, _ = modèle. ParseFiles("tutoriel.html")
événement := Actualités{
 Titre: "makeuseof.com a tout de la Tech",
 Corps: "Visitez MUO pour tout ce qui touche à la technologie",
 }


erreur := tmplt. Exécuter (écrivain, événement)
si erreur != néant {
revenir
 }
 }
}

La ParseFiles La méthode analyse le fichier HTML que vous spécifiez. La un événement variable est la structure initialisée. La Exécuter La méthode injectera les données fournies dans la page finale, selon les espaces réservés du modèle. Exécuter prend un ResponseWriter et les données, dans ce cas, la structure.

Voici le résultat de l'exécution du serveur et de la visite de la page :

Utilisation des structures de contrôle dans les modèles

Vous pouvez également utiliser des structures de contrôle telles que des instructions conditionnelles et des boucles dans vos modèles.

Une boucle vous permet de sortir plusieurs valeurs et de réutiliser la même structure pour chacune. Utilisez le intervalle mot-clé pour définir le début du contenu répété et le fin mot-clé pour la fin. Dans la boucle, vous pouvez utiliser le {{.}} syntaxe pour injecter la valeur courante :

    

     {{intervalle .}}
  1. {{.}}
    2. 

     {{fin}}

Ensuite, vous passerez le nom de la structure de données que vous souhaitez parcourir en tant que paramètre à la méthode Execute :

makeUseOfCategories := []chaîne de caractères{"La technologie expliquée", "Programmation", "Linux",
 "Android", "iOS", "Beaucoup d'autres..."}
erreur := tmplt. Exécuter (écrivain, makeUseOfCategories)
si erreur != néant {
revenir
}

La makeUseOfCategories variable est une tranche de chaînes à transmettre en tant que paramètre de données. Voici le résultat de la boucle sur la tranche :

Vous pouvez utiliser une instruction conditionnelle dans vos modèles pour tester la valeur d'une variable booléenne. Créez une structure avec des champs booléens, comme ceci :

taper VraiFaux structure {
 Est vrai bourdonner
 C'est faux bourdonner
 EstParDéfaut bourdonner
}

Pour utiliser une condition, incluez le si mot-clé entre doubles accolades avant le nom de la variable à tester. Terminez le bloc conditionnel avec le fin mot-clé entre accolades :

{{si .IsTrue}}
<p>Évalue vrai et affichera</p>
{{fin}}
{{if .IsDefault}}
<p>Évalue faux et gagné't sortie</p>
{{fin}}
{{si .IsFalse}}
<p>Évalue faux et gagné't sortie</p>
{{fin}}

L'initialisation d'une structure dans Go définit les valeurs sur false par défaut, donc si vous n'initialisez pas un champ, il est évalué sur false. Lors de l'initialisation de la structure et de la transmission de la variable en tant que données au modèle, seuls les champs dont la valeur est true entraînent l'affichage de la sortie.

choix := VraiFaux {
 Est vrai: vrai,
 C'est faux: faux,
}
erreur := tmplt. Exécuter (écrivain, choix)

La sortie finale ne comprend qu'un seul paragraphe puisque seul le champ isTrue prend la valeur true :

Vous n'avez pas besoin d'utiliser des modèles pour vos applications backend

La création de modèles n'est pas obligatoire pour vos applications Go. Vous pouvez utiliser d'autres approches comme l'intégration de la structure de votre page dans votre programme, parallèlement à sa logique et à d'autres comportements.

Cependant, vous finirez par faire plus de travail pour vous-même. Les modèles Go aident à prévenir les attaques XSS et facilitent la séparation du travail sur la structure de la page de la logique backend.