Comment inclure des templates HTML les uns dans les autres ?

Les templates imbriqués sont très pratiques pour éviter de dupliquer du code de présentation. Par exemple, pour avoir une section HEAD ou un pied de page commun à toutes les pages de votre application. On pourrait également vouloir créer une page maître et des vues pour son application. Commençons par un exemple simple de deux pages index.html et page.html avec une section HEAD commune et une section BODY spécifique à chacune des pages.
  • Principe des fichiers template imbriqués

Créer les fichiers template

Contenu du fichier base.html :
{{define "base"}}<html>
  <head>{{template "head" .}}</head>
  <body>{{template "body" .}}</body>
 </html>{{end}}
Contenu du fichier index.html :
{{define "head"}}<title>{{ .Titre }}</title>{{end}}
{{define "body"}}index{{end}}
Contenu du fichier page.html :
{{define "head"}}<title>{{ .Titre }}</title>{{end}}
{{define "body"}}page{{end}}
On note que nous avons défini le template "template" dans un des fichiers template. Il aura été tout à fait possible de le définir dans un fichier à part.

Définition des relations entre les fichiers template

L'idée est de créer une map décrivant ces ensembles de templates (par exemple, index.html est composé de index.html et de base.html).
tmpl := make(map[string]*template.Template)
tmpl["index.html"] = template.Must(template.ParseFiles("index.html", "base.html"))
tmpl["page.html"] = template.Must(template.ParseFiles("page.html", "base.html"))
Toutes les dépendances entre les templates doivent être satisfaites. Par exemple, si vous décidiez de séparer la section HEAD et de la définir dans un fichier à part (par exemple header.html), alors il faudrait ajouter header.html dans la liste des paramètres de la fonction template.ParseFiles.

Exemple de code

On peut maintenant – dans un contrôleur – effectuer le rendu du templateindex.html :
 tmpl["index.html"].Execute(w, "base", p) 
Ou encore le rendu du templatepage.html :
 tmpl["page.html"].Execute(w, "base", p)
p étant une variable contenant les données à envoyer au template (voir cet article sur le fonctionnement des applications web en golang).

Portée des variables

Lorsque l'on definit un ensemble de templates, un bloc de cet ensemble a accès aux autres blocs définis dans cet ensemble. Autrement dit, écrire ce code :
tmpl["index.html"] = template.Must(template.ParseFiles("index.html", "base.html"))
revient à créer ce template :
<html>
<head><title>{{ .Titre }}</title></head>
<body>index</body>
</html>
On peut donc accéder à une variable envoyée lors de l'exécution du template dans n'importe lequel des fichiers le constituant.

Étiquettes :   webapp 
Portrait de Benjamin BALET
Benjamin BALET
Consultant APM

Retrouvez mes cooordonées

Benjamin BALET sur viadeo






Vous aimerez aussi

Les lois de la réflexion

Une traduction du blog officiel de golang expliquant le mécanisme de la réflexion en Go.   Lire »

Gobs le format natif d'échange de données en Go

Traduction d'un article du blog officiel expliquant comment échanger des données entre deux programmes golang grâce à un format natif   Lire »

Comment écrire du code Go ?

Traduction d'une partie des spécifications officielles du langage Go, cet article explique comment développer en Go.   Lire »

Canaux et go routines avec ou sans état

Exemples d'utilisation du type chan et des go routines stateful et stateless   Lire »

Gérer les informations de session avec Gorilla

La bibliothèque standard de go ne gère pas les variables de session d'une application. Il existe une solution avec le toolkit Gorilla   Lire »

Commentaires

Soyez le premier à commenter cet article

Publier un commentaires

Tous les commentaires sont soumis à modération. Les balises HTML sont pour la plupart autorisées. Les liens contextuels et intéressants sont en follow.

(requis)
(requis)
(requis, mais non publié)
(recommandé si vous souhaitez être publié)