Wanneer u een website bouwt, genereert u doorgaans een deel van uw uiteindelijke inhoud dynamisch. U wilt die gegevens vervolgens in uw uiteindelijke webpagina's injecteren voor weergave in een browser.

U kunt twee benaderingen volgen: uw paginastructuur in uw programma insluiten, of uw uiteindelijke gegevens combineren met afzonderlijke sjabloonbestanden.

Sjablonen biedt scheiding van zorgen voor een beter onderhoudbare codebase. Het maakt het ook gemakkelijker om front-end-taken en back-end-taken te splitsen en aan verschillende teamleden toe te wijzen. Go heeft uitstekende ondersteuning voor sjablonen in zijn standaardbibliotheek.

Aan de slag met sjablonen in Go

Go heeft twee sjablonenpakketten in de standaardbibliotheek: tekst/sjabloon en html/sjabloon. Het tekst/sjabloonpakket heeft functionaliteit voor het ontleden van tekstbestanden, terwijl html/sjabloon HTML verwerkt. Door de html/sjabloon te gebruiken, bent u beveiligd tegen cross-site scripting (XSS)-aanvallen, aangezien Go tijdens het renderen aan gegevensinvoer ontsnapt. Dit is een ander voordeel van sjablonen ten opzichte van een handmatige aanpak.

instagram viewer

Aangezien het sjabloonpakket deel uitmaakt van de standaardbibliotheek, hoeft u geen afhankelijkheden te installeren; importeer het gewoon:

importeren "html/sjabloon"

Start op een HTML-bestand maken om als sjabloon voor uw toepassing te gebruiken. U kunt de standaard gebruiken .html extensie of een van beide .gohtml of .tmpl, beide zijn die ook vaak voorkomen. Welke extensie u ook gebruikt, de functionaliteit binnen uw applicatie zal hetzelfde zijn. Sommige teksteditors kunnen verschillende syntaxisaccentuering toepassen, afhankelijk van de extensies van uw sjablonen. Hier is een basisskelet:

<!DOCTYPE html>
<html lang="en">
<hoofd>
<meta-tekenset="UTF-8">
<titel>Document</title>
</head>
<lichaam>
</body>
</html>

Sla dit bestand op in de map van uw Go-programma. U kunt er nu mee aan de slag, als sjabloon, binnen uw programma.

Maak een globaal exemplaar van de Sjabloon methode van het sjabloonpakket. U krijgt toegang tot deze sjablooninstantie vanuit verschillende delen van uw programma.

var tmplt *sjabloon. Sjabloon

U moet een eenvoudige server maken om uw sjablonen weer te geven en weer te geven. Hier leest u hoe u een eenvoudige server in Go start met behulp van de net/http pakket:

funcrunServer() {
 http. HandleFunc("/home", handlePage)
 fout := http. ListenAndServe("localhost:8080", nul)
als fout != nul {
 logboek. Fatalln("Er is een fout opgetreden met de server:", err)
 }
}

Je belt de runServer functie van uw hoofdfunctie om de server te starten. De server heeft maar één route, de /home route, die uw pagina zal weergeven. De handvatPagina parameter is de naam van een handlerfunctie die uw pagina zal weergeven. De LuisterEnServe methode start de server die luistert op poort 8080 Aan localhost, d.w.z. je eigen computer.

Variabelen doorgeven aan sjablonen

Maak een globale structuur met de naam Nieuws:

type Nieuws structureren {
 kop snaar
 Lichaam snaar
}

U gebruikt deze structuur om gegevens op te slaan en door te geven aan uw sjabloon voor weergave op uw laatste pagina. In uw sjabloon kunt u vervolgens deze syntaxis gebruiken om gegevens in te voegen:

{{ naam }}

Waar naam is de naam van een variabele die u aan uw sjabloon hebt doorgegeven. Wanneer u de sjabloon rendert, worden waarden tussen accolades vervangen door overeenkomstige gegevens uit uw Go-code. Aangezien het volgende voorbeeld een struct doorgeeft, gebruikt u puntnotatie om toegang te krijgen tot de velden:

<lichaam>
<h1>{{ .Koptekst }}</h1>
<p> {{ .Lichaam }} </p>
</body>

Vervang het lege body-element in de skeletopmaak van uw sjabloon door de bovenstaande code.

De handvatPagina handler-functie zal verifiëren dat het verzoek voor de pagina een GET-verzoek is. Vervolgens wordt een structuur gevuld met voorbeeldgegevens voordat de sjabloon wordt weergegeven en de laatste pagina wordt weergegeven:

funchandvatPagina(schrijver http. ResponseWriter, verzoek *http. Verzoek) {
als verzoek. Methode == "KRIJGEN" {
 tmplt, _ = sjabloon. ParseFiles("tutorial.html")
evenement := Nieuws{
 Kop: "makeuseof.com heeft alles Tech",
 Tekst: "Bezoek MUO voor alles wat met technologie te maken heeft",
 }


fout := tmplt. Uitvoeren (schrijver, evenement)
als fout != nul {
opbrengst
 }
 }
}

De ParseFiles methode parseert het HTML-bestand dat u opgeeft. De evenement variabele is de geïnitialiseerde structuur. De uitvoeren methode zal de aangeleverde gegevens invoegen op de laatste pagina, volgens de tijdelijke aanduidingen in de sjabloon. Uitvoeren duurt een Reactieschrijver en de data, in dit geval de struct.

Dit is het resultaat van het uitvoeren van de server en het bezoeken van de pagina:

Besturingsstructuren gebruiken in sjablonen

U kunt ook besturingsstructuren zoals voorwaardelijke instructies en lussen in uw sjablonen gebruiken.

Met een lus kunt u verschillende waarden uitvoeren en voor elk dezelfde structuur opnieuw gebruiken. Gebruik de bereik trefwoord om het begin van de herhaalde inhoud te definiëren en de einde trefwoord voor het einde. Binnen de lus kunt u de {{.}} syntaxis om de huidige waarde te injecteren:

    

     {{bereik .}}
  1. {{.}}
    2. 

     {{einde}}

Vervolgens geeft u de naam van de datastructuur die u wilt doorlopen als parameter door aan de Execute-methode:

makeUseOfCategories := []snaar{"Technologie uitgelegd", "Programmeren", "Linux",
 "Android", "iOS", "Veel meer..."}
fout := tmplt. Uitvoeren (schrijver, makeUseOfCategories)
als fout != nul {
opbrengst
}

De makeUseOfCategories variabele is een stuk tekenreeksen dat moet worden doorgegeven als de gegevensparameter. Hier is het resultaat van het doorlopen van het segment:

U kunt een voorwaardelijke instructie in uw sjablonen gebruiken om de waarde van een booleaanse variabele te testen. Maak een struct met booleaanse velden, zoals deze:

type TrueFalser structureren {
 Is waar bool
 Is fout bool
 IsStandaard bool
}

Om een ​​voorwaardelijke te gebruiken, voeg je de als trefwoord tussen dubbele accolades voor de naam van de te testen variabele. Beëindig het voorwaardelijke blok met de einde trefwoord tussen haakjes:

{{if .IsTrue}}
<p>Evalueert waar en zal uitvoer</p>
{{einde}}
{{if .IsDefault}}
<p>Evalueert vals en gewonnen't uitgang</p>
{{einde}}
{{if .IsFalse}}
<p>Evalueert vals en gewonnen't uitgang</p>
{{einde}}

Het initialiseren van een struct in Go stelt de waarden standaard in op false, dus als u een veld niet initialiseert, wordt het geëvalueerd op false. Bij het initialiseren van de struct en het doorgeven van de variabele als de gegevens aan de sjabloon, veroorzaken alleen de velden die worden geëvalueerd als waar, uitvoer wordt weergegeven.

keuze := TrueFalser {
 Is waar: WAAR,
 Is fout: vals,
}
fout := tmplt. Uitvoeren (schrijver, keuze)

De uiteindelijke uitvoer bevat slechts één alinea, omdat alleen het veld isTrue als waar wordt geëvalueerd:

U hoeft geen sjablonen te gebruiken voor uw backend-applicaties

Sjablonen is geen vereiste voor uw Go-apps. U kunt andere benaderingen gebruiken, zoals het insluiten van uw paginastructuur in uw programma, naast de logica en ander gedrag.

Maar uiteindelijk maak je meer werk voor jezelf. Go-templating helpt XSS-aanvallen te voorkomen en maakt het gemakkelijker om werk aan paginastructuur te scheiden van backend-logica.