När du bygger en webbplats genererar du vanligtvis en del av ditt slutliga innehåll dynamiskt. Du vill sedan injicera den informationen i dina slutliga webbsidor för visning i en webbläsare.

Du kan använda ett av två tillvägagångssätt: bädda in din sidstruktur i ditt program eller kombinera dina slutliga data med separata mallfiler.

Mallar ger åtskillnad mellan problem för en mer underhållbar kodbas. Det gör det också lättare att dela upp front-end-uppgifter och back-end-uppgifter och allokera dem till olika teammedlemmar. Go har utmärkt stöd för mallar i sitt standardbibliotek.

Komma igång med mall i Go

Go har två mallpaket i standardbiblioteket: text/mall och html/mall. Text/mallpaketet har funktionalitet för att analysera textfiler, medan html/mall hanterar HTML. Genom att använda html/mallen är du säkrad från cross-site scripting (XSS) attacker eftersom Go undkommer datainmatning under rendering. Detta är en annan fördel med mallar framför ett manuellt tillvägagångssätt.

Eftersom mallpaketet är en del av standardbiblioteket behöver du inte installera några beroenden; bara importera det:

instagram viewer 

importera "html/mall"

Börja med skapa en HTML-fil att använda som mall för din ansökan. Du kan använda standarden .html förlängning eller antingen .gohtml eller .tmpl, båda är som också är vanliga. Oavsett vilket tillägg du använder kommer funktionaliteten i din applikation att vara densamma. Vissa textredigerare kan tillämpa olika syntaxmarkering beroende på mallarnas tillägg. Här är ett grundläggande skelett:

<!DOCTYPE html>
<html lang="sv">
<huvud>
<meta teckenuppsättning="UTF-8">
<titel>Dokumentera</title>
</head>
<kropp>
</body>
</html>

Spara den här filen i ditt Go-programs katalog. Du kan nu börja arbeta med den, som en mall, i ditt program.

Skapa en global instans av Mall mallpaketets metod. Du kommer åt den här mallinstansen från olika delar av ditt program.

var tmplt *mall. Mall

Du måste skapa en enkel server för att rendera och visa dina mallar. Så här startar du en enkel server i Go med hjälp av net/http paket:

funckörServer() {
 http. HandleFunc("/home", handlePage)
 fel := http. ListenAndServe("localhost:8080", noll)
om fel!= noll {
 logga. Fatalln("Det är ett fel med servern:", err)
 }
}

Du kommer att ringa körServer funktion från din huvudfunktion för att starta servern. Servern har bara en rutt, den /home rutt, som visar din sida. De handtagssida parameter är namnet på en hanterarfunktion som renderar din sida. De ListenAndServe metoden startar servern att lyssna på porten 8080 på localhost, det vill säga din egen dator.

Överföra variabler till mallar

Skapa en global struktur med namnet Nyheter:

typ Nyheter struktur {
 Rubrik sträng
 Kropp sträng
}

Du kommer att använda den här strukturen för att lagra data och skicka den till din mall för visning på din sista sida. I din mall kan du sedan använda denna syntax för att injicera data:

{{ namn }}

Var namn är namnet på en variabel som du har skickat till din mall. När du renderar mallen kommer den att ersätta värden inom klammerparenteser med motsvarande data från din Go-kod. Eftersom följande exempel kommer att skicka en struktur kommer du att använda punktnotation för att komma åt dess fält:

<kropp>
<h1>{{ .Headline }}</h1>
<sid> {{ .Body }} </s>
</body>

Byt ut det tomma kroppselementet i mallens skelettuppmärkning med koden ovan.

De handtagssida hanterarfunktionen kommer att verifiera att begäran för sidan är en GET-förfrågan. Den fyller sedan i en struktur med exempeldata innan mallen renderas och den sista sidan visas:

funchandtagssida(författare http. ResponseWriter, begär *http. Begäran) {
om begäran. Metod == "GET" {
 tmplt, _ = mall. ParseFiles("tutorial.html")
händelse := Nyheter{
 Rubrik: "makeuseof.com har allt tekniskt",
 Kropp: "Besök MUO för allt teknikrelaterat",
 }


fel := tmplt. Utför (skribent, händelse)
om fel!= noll {
lämna tillbaka
 }
 }
}

De ParseFiles metod analyserar HTML-filen du anger. De händelse variabeln är den initierade strukturen. De Kör metod kommer att injicera den tillhandahållna informationen på den sista sidan, enligt platshållarna i mallen. Execute tar en ResponseWriter och data, i detta fall strukturen.

Här är resultatet från att köra servern och besöka sidan:

Använda kontrollstrukturer i mallar

Du kan också använda kontrollstrukturer som villkorliga uttalanden och loopar i dina mallar.

En loop låter dig mata ut flera värden och återanvända samma struktur för varje. Använd räckvidd nyckelord för att definiera början av det upprepade innehållet och slutet nyckelord för slutet. Inom slingan kan du använda {{.}} syntax för att injicera det aktuella värdet:

    

     {{räckvidd .}}
  1. {{.}}
    2. 

     {{slutet}}

Sedan skickar du namnet på datastrukturen du vill gå igenom som en parameter till Execute-metoden:

makeUseOfCategories := []sträng{"Teknik förklaras", "Programmering", "Linux",
 "Android", "iOS", "Många fler..."}
fel := tmplt. Execute (skribent, makeUseOfCategories)
om fel!= noll {
lämna tillbaka
}

De makeUseOfCategories variabel är en del av strängar som ska skickas som dataparameter. Här är resultatet av att gå igenom skivan:

Du kan använda en villkorssats i dina mallar för att testa värdet på en boolesk variabel. Skapa en struktur med booleska fält, så här:

typ TrueFalser struktur {
 Är sant bool
 Är Falskt bool
 IsDefault bool
}

För att använda en villkorad, inkludera om nyckelord med dubbla klammerparenteser före namnet på variabeln som ska testas. Avsluta det villkorliga blocket med slutet nyckelord inom hängslen:

{{if .IsTrue}}
<sid>Utvärderar sann och kommer att utdata</s>
{{slutet}}
{{if .IsDefault}}
<sid>Bedömer falskt och vann't utgång</s>
{{slutet}}
{{if .IsFalse}}
<sid>Bedömer falskt och vann't utgång</s>
{{slutet}}

Initiering av en struct i Go ställer in värdena på false på standard, så om du inte initierar ett fält utvärderas det till false. När strukturen initieras och variabeln skickas som data till mallen är det bara de fält som utvärderas till sant som gör att utdata visas.

val := TrueFalser {
 Är sant: Sann,
 IsFalse: falsk,
}
fel := tmplt. Utför (skribent, val)

Den slutliga utdatan innehåller bara ett enda stycke eftersom endast isTrue-fältet utvärderas till sant:

Du behöver inte använda mallar för dina backend-applikationer

Mallar är inte ett krav för dina Go-appar. Du kan använda andra metoder som att bädda in din sidstruktur i ditt program, tillsammans med dess logik och annat beteende.

Men du kommer att göra mer arbete för dig själv. Go-mall hjälper till att förhindra XSS-attacker och gör det lättare att separera arbete på sidstruktur från backend-logik.