Quando crei un sito web, genererai in genere alcuni dei tuoi contenuti finali in modo dinamico. Ti consigliamo quindi di iniettare quei dati nelle tue pagine Web finali per la visualizzazione in un browser.
Puoi adottare uno dei due approcci: incorporare la struttura della pagina nel programma o combinare i dati finali con file modello separati.
La creazione di modelli fornisce la separazione delle preoccupazioni per una base di codice più gestibile. Semplifica inoltre la suddivisione delle attività front-end e back-end, assegnandole a diversi membri del team. Go ha un eccellente supporto per la creazione di modelli nella sua libreria standard.
Guida introduttiva alla creazione di modelli in Go
Go ha due pacchetti di modelli nella libreria standard: testo/modello e html/modello. Il pacchetto text/template ha funzionalità per l'analisi dei file di testo, mentre html/template gestisce HTML. Utilizzando l'html/modello sei protetto dagli attacchi di cross-site scripting (XSS) poiché Go sfugge all'immissione di dati durante il rendering. Questo è un altro vantaggio della creazione di modelli rispetto a un approccio manuale.
Poiché il pacchetto del modello fa parte della libreria standard, non sarà necessario installare alcuna dipendenza; basta importarlo:
importare "html/modello"
A partire da creazione di un file HTML da utilizzare come modello per la tua applicazione. Puoi usare lo standard .html estensione o uno dei due .gohtml o .tmpl, entrambi sono anche comuni. Qualunque sia l'estensione che utilizzi, la funzionalità all'interno della tua applicazione sarà la stessa. Alcuni editor di testo possono applicare un'evidenziazione della sintassi diversa a seconda delle estensioni dei tuoi modelli. Ecco uno scheletro di base:
<!DOCTYPE html>
<lingua html="it">
<testa>
<metacarattere="UTF-8">
<titolo>Documento</title>
</head>
<corpo>
</body>
</html>
Salva questo file nella directory del tuo programma Go. Ora puoi iniziare a lavorarci, come modello, all'interno del tuo programma.
Crea un'istanza globale di Modello metodo del pacchetto modello. Accederai a questa istanza del modello da varie parti del tuo programma.
var tmplt *modello. Modello
Dovrai creare un semplice server per eseguire il rendering e visualizzare i tuoi modelli. Ecco come avviare un semplice server in Go utilizzando il rete/http pacchetto:
funzrunServer() {
http. HandleFunc("/home", handlePage)
err := http. ListenAndServe("host locale:8080", zero)
Se ehm!= zero {
tronco d'albero. Fatalln("Si è verificato un errore con il server:", err)
}
}
Chiamerai il runServer funzione dalla funzione principale per avviare il server. Il server ha un solo percorso, il /home percorso, che visualizzerà la tua pagina. Il handlePage parametro è il nome di una funzione del gestore che renderà la tua pagina. Il Ascolta e servi il metodo avvia il server in ascolto sulla porta 8080 Su localhost, ovvero il tuo computer.
Passaggio di variabili ai modelli
Crea una struttura globale denominata Notizia:
genere Notizia struttura {
Titolo corda
Corpo corda
}
Utilizzerai questa struttura per archiviare i dati e passarli al tuo modello per la visualizzazione nella pagina finale. Nel tuo modello, puoi quindi utilizzare questa sintassi per inserire i dati:
{{ nome }}Dove nome è il nome di una variabile che hai passato al tuo modello. Quando esegui il rendering del modello, sostituirà i valori tra parentesi con i dati corrispondenti dal tuo codice Go. Poiché l'esempio seguente passerà una struttura, utilizzerai la notazione del punto per accedere ai suoi campi:
<corpo>
<h1>{{ .Titolo }}</h1>
<p> {{ .Corpo }} </p>
</body>
Sostituisci l'elemento del corpo vuoto nel markup dello scheletro del tuo modello con il codice sopra.
Il handlePage la funzione del gestore verificherà che la richiesta per la pagina sia una richiesta GET. Quindi popola una struttura con dati di esempio prima di eseguire il rendering del modello e servire la pagina finale:
funzhandlePage(scrittore http. ResponseWriter, richiesta *http. Richiesta) {
Se richiesta. Metodo == "OTTIENI" {
tmplt, _ = modello. ParseFiles("tutorial.html")evento := Notizie{
Titolo: "makeuseof.com ha tutto Tech",
Ente: "Visita MUO per tutto ciò che riguarda la tecnologia",
}err := tmplt. Esegui (scrittore, evento)
Se ehm!= zero {
Restituzione
}
}
}
Il Analizza file il metodo analizza il file HTML specificato. Il evento variabile è la struttura inizializzata. Il Eseguire metodo inietterà i dati forniti nella pagina finale, in base ai segnaposto nel modello. Esegui richiede a Scrittore di risposte e i dati, in questo caso, la struct.
Ecco il risultato dell'esecuzione del server e della visita alla pagina:
Utilizzo delle strutture di controllo nei modelli
Puoi anche utilizzare strutture di controllo come istruzioni condizionali e loop nei tuoi modelli.
Un ciclo consente di emettere diversi valori e di riutilizzare la stessa struttura per ciascuno. Utilizzare il gamma parola chiave per definire l'inizio del contenuto ripetuto e il fine parola chiave per la fine. All'interno del ciclo puoi usare il {{.}} sintassi per iniettare il valore corrente:
{{gamma .}}
- {{.}}
{{fine}}
Quindi passerai il nome della struttura dati che desideri scorrere come parametro al metodo Execute:
makeUseOfCategories := []corda{"Spiegazione della tecnologia", "Programmazione", "Linux",
"Android", "iOS", "Molti altri..."}err := tmplt. Esegui (scrittore, makeUseOfCategories)
Se ehm!= zero {
Restituzione
}
Il makeUseOfCategories variabile è una porzione di stringhe da passare come parametro di dati. Ecco il risultato del ciclo della fetta:
Puoi utilizzare un'istruzione condizionale nei tuoi modelli per testare il valore di una variabile booleana. Crea una struttura con campi booleani, in questo modo:
genere Vero Falso struttura {
È vero bollo
È falso bollo
È predefinito bollo
}
Per utilizzare un condizionale, includi il Se parola chiave tra parentesi doppie prima del nome della variabile da testare. Termina il blocco condizionale con il fine parola chiave tra parentesi:
{{se .è vero}}
<p>Valuta vero e produrrà</p>
{{fine}}{{se .IsDefault}}
<p>Valuta falsa e vinta't uscita</p>
{{fine}}
{{se .è falso}}
<p>Valuta falsa e vinta't uscita</p>
{{fine}}
L'inizializzazione di una struttura in Go imposta i valori su false per impostazione predefinita, quindi se non si inizializza un campo, restituisce false. Durante l'inizializzazione della struttura e il passaggio della variabile come dati al modello, solo i campi che restituiscono true fanno apparire l'output.
scelta := Vero Falso {
È vero: VERO,
È falso: falso,
}
err := tmplt. Esegui (scrittore, scelta)
L'output finale include solo un singolo paragrafo poiché solo il campo isTrue restituisce true:
Non devi utilizzare i modelli per le tue applicazioni di back-end
La creazione di modelli non è un requisito per le tue app Go. Puoi utilizzare altri approcci come incorporare la struttura della tua pagina nel tuo programma, insieme alla sua logica e ad altri comportamenti.
Tuttavia, finirai per fare più lavoro per te stesso. I modelli Go aiutano a prevenire gli attacchi XSS e semplificano la separazione del lavoro sulla struttura della pagina dalla logica di back-end.