È possibile avere modelli nidificati in Go utilizzando la libreria standard?

Question 1

Come ottengo modelli annidati come quelli di Jinja nel runtime di Python. TBC quello che intendo è come faccio a far ereditare un sacco di modelli da un modello di base, semplicemente archiviando in blocchi dei modelli di base, come fa Jinja / django-templates. È possibile utilizzare solo html/templatenella libreria standard.

Se questa non è una possibilità, quali sono le mie alternative. I baffi sembrano essere un'opzione, ma allora mi perderei quelle belle caratteristiche sottili html/templatecome la fuga sensibile al contesto, ecc.? Quali altre alternative ci sono?

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

Grazie per aver letto.

Question 2

Sì, è possibile. A html.Templateè in realtà un insieme di file modello. Se si esegue un blocco definito in questo set, ha accesso a tutti gli altri blocchi definiti in questo set.

Se crei una mappa di tali set di modelli da solo, hai fondamentalmente la stessa flessibilità offerta da Jinja / Django. L'unica differenza è che il pacchetto html / template non ha accesso diretto al file system, quindi devi analizzare e comporre i modelli da solo.

Considera il seguente esempio con due pagine diverse ("index.html" e "other.html") che ereditano entrambe da "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}}

E la seguente mappa di set di modelli:

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"))

Ora puoi eseguire il rendering della tua pagina "index.html" chiamando

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

e puoi visualizzare la tua pagina "altro.html" chiamando

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

Con alcuni accorgimenti (ad es. Una convenzione di denominazione coerente dei file modello), è persino possibile generare tmplautomaticamente la mappa.

Question 3

nota, quando esegui il tuo modello di base, devi passare i valori ai modelli figli, qui passo semplicemente ".", in modo che tutto venga trasmesso.

il modello uno mostra {{.}}

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

il modello due mostra {{.domains}} che è passato al genitore.

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

Nota, se usassimo {{template "content".}} Invece di {{template "content".}}, .Domains non sarebbe accessibile dal modello di contenuto.

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

avendo lavorato con altri pacchetti di template, ora lavoro principalmente con il pacchetto standard html / template, credo di essere stato ingenuo a non apprezzare la semplicità che fornisce e altre chicche. Uso un approccio molto simile alla risposta accettata con le seguenti modifiche

non è necessario avvolgere i layout con un basemodello aggiuntivo , viene creato un blocco modello per ogni file analizzato quindi in questo caso è ridondante, mi piace anche usare l'azione di blocco fornita nella nuova versione di go, che ti permette di avere contenuto del blocco predefinito nel caso in cui non ne venga fornito uno nei modelli figlio

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

e i tuoi modelli di pagina possono essere gli stessi di

// 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}}

ora per eseguire i modelli è necessario chiamarlo in questo modo

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

Question 5

Usa Pongo , che è un super-set di modelli Go che supporta i tag {{extends}} e {{block}} per l'ereditarietà dei modelli, proprio come Django.

Question 6

Sono tornato a questa risposta per giorni, finalmente ho morso il proiettile e ho scritto un piccolo strato di astrazione / pre processore per questo. Fondamentalmente:

Aggiunge la parola chiave "extends" ai modelli.
Consente l'override delle chiamate di "definizione" (quindi sono possibili valori predefiniti per greggory)
Consente chiamate "modello" non definite, forniscono solo una stringa vuota
Imposta il valore predefinito di. nelle chiamate "modello" a. del genitore

https://github.com/daemonl/go_sweetpl