Når du bygger et nettsted, genererer du vanligvis noe av det endelige innholdet ditt dynamisk. Du vil da injisere disse dataene i de endelige nettsidene dine for visning i en nettleser.

Du kan bruke en av to tilnærminger: bygge inn sidestrukturen i programmet, eller kombiner de endelige dataene med separate malfiler.

Maling gir separasjon av bekymringer for en mer vedlikeholdbar kodebase. Det gjør det også enklere å dele front-end-oppgaver og back-end-oppgaver, og tildele dem til forskjellige teammedlemmer. Go har utmerket malstøtte i standardbiblioteket.

Komme i gang med maling i Go

Go har to malpakker i standardbiblioteket: tekst/mal og html/mal. Tekst/malpakken har funksjonalitet for å analysere tekstfiler, mens html/mal håndterer HTML. Ved å bruke html/malen er du sikret mot cross-site scripting (XSS)-angrep siden Go unnslipper dataregistrering under gjengivelse. Dette er en annen fordel med maling fremfor en manuell tilnærming.

Siden malpakken er en del av standardbiblioteket, trenger du ikke å installere noen avhengigheter; bare importer det:

import "html/mal"

Start med lage en HTML-fil å bruke som mal for søknaden din. Du kan bruke standarden .html utvidelse eller enten .gohtml eller .tmpl, begge er som også er vanlige. Uansett hvilken utvidelse du bruker, vil funksjonaliteten i applikasjonen din være den samme. Noen tekstredigerere kan bruke forskjellig syntaksutheving avhengig av malenes utvidelser. Her er et grunnleggende skjelett:

<!DOCTYPE html>
<html lang="no">
<hode>
<metategnsett="UTF-8">
<tittel>Dokument</title>
</head>
<kropp>
</body>
</html>

Lagre denne filen i Go-programmets katalog. Du kan nå begynne å jobbe med det, som en mal, i programmet ditt.

Lag en global forekomst av Mal metoden for malpakken. Du får tilgang til denne malforekomsten fra ulike deler av programmet.

var tmplt *mal. Mal

Du må lage en enkel server for å gjengi og vise malene dine. Slik starter du en enkel server i Go ved å bruke net/http pakke:

funckjøreServer() {
 http. HandleFunc("/home", handlePage)
 feil := http. ListenAndServe("localhost:8080", null)
hvis feil!= null {
 Logg. Fatalln("Det er en feil med serveren:", err)
 }
}

Du vil ringe kjøreServer funksjon fra hovedfunksjonen din for å starte serveren. Serveren har bare én rute, den /home rute, som viser siden din. De handleside parameter er navnet på en behandlerfunksjon som vil gjengi siden din. De ListenAndServe metoden starter serveren å lytte på porten 8080 på localhost, dvs. din egen datamaskin.

Sende variabler til maler

Lag en global struktur kalt Nyheter:

type Nyheter struktur {
 Overskrift streng
 Kropp streng
}

Du bruker denne strukturen til å lagre data og sende dem til malen din for visning på den siste siden. I malen din kan du deretter bruke denne syntaksen til å injisere data:

{{ Navn }}

Hvor Navn er navnet på en variabel du har sendt til malen din. Når du gjengir malen, vil den erstatte verdier i parentes med tilsvarende data fra Go-koden din. Siden følgende eksempel vil sende en struktur, vil du bruke punktnotasjon for å få tilgang til feltene:

<kropp>
<h1>{{ .Headline }}</h1>
<s> {{ .Kropp }} </s>
</body>

Bytt ut det tomme hovedelementet i malens skjelettmerking med koden ovenfor.

De handleside behandlerfunksjonen vil bekrefte at forespørselen for siden er en GET-forespørsel. Den fyller deretter ut en struktur med eksempeldata før malen gjengis og den siste siden vises:

funchandleside(skribent http. ResponseWriter, be om *http. Be om) {
hvis be om. Metode == "GET" {
 tmplt, _ = mal. ParseFiles("tutorial.html")
hendelse := Nyheter{
 Overskrift: "makeuseof.com har alt teknisk",
 Body: "Besøk MUO til alt teknologirelatert",
 }


feil := tmplt. Utfør (skribent, hendelse)
hvis feil!= null {
komme tilbake
 }
 }
}

De ParseFiles metoden analyserer HTML-filen du spesifiserer. De begivenhet variabel er den initialiserte strukturen. De Henrette metoden vil injisere de oppgitte dataene på den siste siden, i henhold til plassholderne i malen. Utfør tar en ResponseWriter og dataene, i dette tilfellet, strukturen.

Her er resultatet fra å kjøre serveren og besøke siden:

Bruke kontrollstrukturer i maler

Du kan også bruke kontrollstrukturer som betingede utsagn og løkker i malene dine.

En loop lar deg skrive ut flere verdier og gjenbruke den samme strukturen for hver. Bruke område nøkkelord for å definere begynnelsen av det gjentatte innholdet og slutt nøkkelord for slutten. Innenfor løkken kan du bruke {{.}} syntaks for å injisere gjeldende verdi:

    

     {{område .}}
  1. {{.}}
    2. 

     {{slutt}}

Deretter sender du navnet på datastrukturen du vil gå gjennom som en parameter til Utfør-metoden:

makeUseOfCategories := []streng{"Teknologi forklart", "Programmering", "Linux",
 "Android", "iOS", "Mange flere..."}
feil := tmplt. Utfør (skribent, makeUseOfCategories)
hvis feil!= null {
komme tilbake
}

De makeUseOfCategories variabel er en del av strenger som skal sendes som dataparameter. Her er resultatet av å gå gjennom skiven:

Du kan bruke en betinget setning i malene dine for å teste verdien av en boolsk variabel. Lag en struktur med boolske felt, slik:

type TrueFalser struktur {
 Er sant bool
 Er Falsk bool
 ErDefault bool
}

For å bruke en betinget, ta med hvis nøkkelord i doble klammeparenteser før navnet på variabelen som skal testes. Avslutt den betingede blokken med slutt nøkkelord i klammeparenteser:

{{if .IsTrue}}
<s>Evaluerer sann og vil utgang</s>
{{slutt}}
{{if .IsDefault}}
<s>Evaluerer falsk og vant't utgang</s>
{{slutt}}
{{if .IsFalse}}
<s>Evaluerer falsk og vant't utgang</s>
{{slutt}}

Initialisering av en struct i Go setter verdiene til false på standard, så hvis du ikke initialiserer et felt, evalueres det til false. Ved initialisering av strukturen og overføring av variabelen som data til malen, er det bare feltene som evalueres til sanne som forårsaker at utdata vises.

valg := TrueFalser {
 Er sant: ekte,
 Er falsk: falsk,
}
feil := tmplt. Utfør (skribent, valg)

Den endelige utgangen inkluderer bare et enkelt avsnitt siden bare isTrue-feltet evalueres til sant:

Du trenger ikke å bruke maler for backend-applikasjonene dine

Maling er ikke et krav for Go-appene dine. Du kan bruke andre tilnærminger som å bygge inn sidestrukturen i programmet, sammen med dets logikk og annen oppførsel.

Du vil imidlertid ende opp med å gjøre mer arbeid for deg selv. Go-mal bidrar til å forhindre XSS-angrep og gjør det enklere å skille arbeid på sidestruktur fra backend-logikk.