Est-il possible d'avoir des modèles imbriqués dans Go en utilisant la bibliothèque standard?

Question 1

Comment obtenir des modèles imbriqués comme Jinja dans le runtime python. TBC ce que je veux dire, c'est comment puis-je faire hériter d'un tas de modèles d'un modèle de base, en déposant simplement des blocs des modèles de base, comme le fait Jinja / django-templates. Est-il possible d'utiliser uniquement html/templatedans la bibliothèque standard.

Si ce n'est pas une possibilité, quelles sont mes alternatives. La moustache semble être une option, mais est-ce que je passerais alors à côté de ces jolies fonctionnalités subtiles telles html/templateque l'échappement sensible au contexte, etc.? Quelles sont les autres alternatives?

(Environnement: Google App Engin, Go runtime v1, Dev - Mac OSx lion)

Merci d'avoir lu.

Question 2

Oui c'est possible. A html.Templateest en fait un ensemble de fichiers modèles. Si vous exécutez un bloc défini dans cet ensemble, il a accès à tous les autres blocs définis dans cet ensemble.

Si vous créez vous-même une carte de ces ensembles de modèles, vous avez fondamentalement la même flexibilité qu'offre Jinja / Django. La seule différence est que le package html / template n'a pas d'accès direct au système de fichiers, vous devez donc analyser et composer les modèles vous-même.

Prenons l'exemple suivant avec deux pages différentes ("index.html" et "other.html") qui héritent toutes deux de "base.html":

// Content of base.html:
{{define "base"}}<html>
  <head>{{template "head" .}}</head>
  <body>{{template "body" .}}</body>
</html>{{end}}

// Content of index.html:
{{define "head"}}<title>index</title>{{end}}
{{define "body"}}index{{end}}

// Content of other.html:
{{define "head"}}<title>other</title>{{end}}
{{define "body"}}other{{end}}

Et la carte suivante des ensembles de modèles:

tmpl := make(map[string]*template.Template)
tmpl["index.html"] = template.Must(template.ParseFiles("index.html", "base.html"))
tmpl["other.html"] = template.Must(template.ParseFiles("other.html", "base.html"))

Vous pouvez maintenant afficher votre page "index.html" en appelant

tmpl["index.html"].Execute("base", data)

et vous pouvez afficher votre page "other.html" en appelant

tmpl["other.html"].Execute("base", data)

Avec quelques astuces (par exemple une convention de dénomination cohérente de vos fichiers modèles), il est même possible de générer la tmplcarte automatiquement.

Question 3

notez que lorsque vous exécutez votre modèle de base, vous devez transmettre des valeurs aux modèles enfants, ici je passe simplement ".", pour que tout soit transmis.

le modèle un affiche {{.}}

{{define "base"}}
<html>
        <div class="container">
            {{.}}
            {{template "content" .}}
        </div>
    </body>
</html>
{{end}}

le modèle deux affiche {{.domains}} qui est passé au parent.

{{define "content"}}
{{.domains}}
{{end}}

Notez que si nous utilisions {{template "content".}} Au lieu de {{template "content".}}, .Domains ne serait pas accessible à partir du modèle de contenu.

DomainsData := make(map[string]interface{})
    DomainsData["domains"] = domains.Domains
    if err := groupsTemplate.ExecuteTemplate(w, "base", DomainsData); err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
    }

Question 4

ayant travaillé avec d'autres packages de modèles, maintenant je travaille principalement avec des packages html / template standard, je suppose que j'étais naïf de ne pas apprécier la simplicité qu'il offre et d'autres goodies. J'utilise une approche très similaire à la réponse acceptée avec les modifications suivantes

vous n'avez pas besoin d'encapsuler vos mises en page avec un basemodèle supplémentaire , un bloc de modèle est créé pour chaque fichier analysé donc dans ce cas, il est redondant, j'aime aussi utiliser l'action de blocage fournie dans la nouvelle version de go, qui vous permet d'avoir contenu de bloc par défaut au cas où vous n'en fournissez pas un dans les modèles enfants

// base.html
<head>{{block "head" .}} Default Title {{end}}</head>
<body>{{block "body" .}} default body {{end}}</body>

et vos modèles de page peuvent être les mêmes que

// Content of index.html:
{{define "head"}}<title>index</title>{{end}}
{{define "body"}}index{{end}}

// Content of other.html:
{{define "head"}}<title>other</title>{{end}}
{{define "body"}}other{{end}}

maintenant pour exécuter les modèles, vous devez l'appeler comme ça

tmpl["index.html"].ExecuteTemplate(os.Stdout, "base.html", data)

Question 5

Utilisez Pongo , qui est un super-ensemble de modèles Go prenant en charge les balises {{extend}} et {{block}} pour l'héritage de modèles, tout comme Django.

Question 6

Je reviens sur cette réponse depuis des jours, j'ai finalement mordu la balle et j'ai écrit une petite couche d'abstraction / pré-processeur pour cela. Il s'agit essentiellement:

Ajoute le mot-clé "extend" aux modèles.
Permet de remplacer les appels 'define' (ainsi les valeurs par défaut pour greggory sont possibles)
Autorise les appels de 'template' non définis, ils donnent juste une chaîne vide
Définit la valeur par défaut de. dans les appels de «modèle» à. du parent

https://github.com/daemonl/go_sweetpl