Quicktemplate Template Library Usage Guide

Vor kurzem, als ich den Code unseres Projekts organisierte, stellte ich fest, dass der Code für viele Aktivitäten in Struktur und den von ihm bereitgestellten Funktionen sehr ähnlich war. Um die zukünftige Entwicklung zu erleichtern, verbrachte ich einige Zeit damit, ein Tool zur Generierung von Code-Frameworks zu schreiben, um sich wiederholende Arbeiten zu minimieren. Der Code selbst ist nicht komplex und steht in engem Zusammenhang mit dem Projektcode, daher werde ich hier nicht ins Detail gehen. Während dieses Prozesses stellte ich fest, dass die Go-Standard-Template-Bibliotheken text/template und html/template ziemlich restriktiv und unbequem zu verwenden waren. Ich erfuhr von GitHub von der Drittanbieter-Template-Bibliothek quicktemplate, die leistungsstark ist, eine einfache Syntax hat und einfach zu bedienen ist. Heute werden wir quicktemplate vorstellen.

Quick Start

Der Code in diesem Artikel verwendet Go Modules.

Initialize the Project

Erstellen Sie zuerst das Codeverzeichnis und initialisieren Sie es:

$ mkdir quicktemplate && cd quicktemplate
$ go mod init github.com/leapcell/quicktemplate

Install Dependencies

quicktemplate konvertiert den von uns geschriebenen Template-Code in Go-Sprachcode. Daher müssen wir das quicktemplate-Paket und einen Compiler namens qtc installieren:

$ go get -u github.com/valyala/quicktemplate
$ go get -u github.com/valyala/quicktemplate/qtc

Write the Template File

Zuerst müssen wir eine Template-Datei im quicktemplate-Format schreiben. Die Template-Datei hat standardmäßig die Erweiterung .qtpl. Hier habe ich eine einfache Template-Datei greeting.qtpl geschrieben:

All text outside function is treated as comments.

{% func Greeting(name string, count int) %}
  {% for i := 0; i < count; i++ %}
    Hello, {%s name %}
  {% endfor %}
{% endfunc %}

Template Syntax Explanation

Die Template-Syntax ist sehr einfach. Wir müssen nur kurz die folgenden zwei Punkte verstehen:

• Templates sind Funktionseinheiten. Funktionen können Parameter beliebigen Typs und beliebiger Anzahl akzeptieren, und diese Parameter können innerhalb der Funktion verwendet werden. Der gesamte Text außerhalb der Funktion ist ein Kommentar, und der qtc-Compiler ignoriert die Kommentare.
• Der Inhalt innerhalb der Funktion, mit Ausnahme der Syntaxstruktur, wird im gerenderten Text unverändert ausgegeben, einschließlich Leerzeichen und Zeilenumbrüche.

Generate and Use the Template

Speichern Sie greeting.qtpl im templates-Verzeichnis und führen Sie dann den Befehl qtc aus. Dieser Befehl generiert die entsprechende Go-Datei greeting.qtpl.go mit dem Paketnamen templates. Jetzt können wir dieses Template verwenden:

package main

import (
  "fmt"

  "github.com/leapcell/quicktemplate/get-started/templates"
)

func main() {
  fmt.Println(templates.Greeting("leapcell", 5))
}

Run the Code

Rufen Sie die Template-Funktion auf, übergeben Sie die Parameter und geben Sie den gerenderten Text zurück:

$ go run .

Ausgabeergebnis:

Hello, leapcell
Hello, leapcell
Hello, leapcell
Hello, leapcell
Hello, leapcell

{%s name %} führt einen Textersatz durch und {% for %} schleift, um wiederholten Text zu generieren. Mehrere Leerzeichen und Zeilenumbrüche werden in der Ausgabe angezeigt, da mit Ausnahme der Syntaxstruktur innerhalb der Funktion andere Inhalte unverändert beibehalten werden, einschließlich Leerzeichen und Zeilenumbrüche.

Notes

Da quicktemplate Templates zur Verwendung in Go-Code konvertiert, muss der Befehl qtc zuerst ausgeführt werden, um den Go-Code neu zu generieren, wenn das Template geändert wird; andernfalls werden die Änderungen nicht wirksam.

Syntax Structure

quicktemplate unterstützt gängige Go-Syntaxstrukturen wie if, for, func, import, return. Und die Art und Weise des Schreibens unterscheidet sich nicht wesentlich vom direkten Schreiben von Go-Code, mit fast keinen Lernkosten. Wenn Sie diese Syntaxen in Templates verwenden, müssen sie jedoch in {% und %} eingeschlossen werden, und if, for usw. müssen endif, endfor hinzufügen, um das Ende deutlich anzuzeigen.

Variables

Oben haben wir bereits gesehen, wie der übergebene Parameter name mit {%s name %} gerendert wird. Da name vom Typ string ist, wird s nach {% verwendet, um den Typ anzugeben. quicktemplate unterstützt auch andere Werttypen:

• Integer: {%d int %}, {%dl int64 %}, {%dul uint64 %}.
• Floating point number: {%f float %}. Sie können auch die Ausgabegenauigkeit festlegen, indem Sie {%f.precision float %} verwenden. Zum Beispiel gibt {%f.2 1.2345 %} 1.23 aus.
• Byte slice ([]byte): {%z bytes %}.
• String: {%q str %} oder Byte slice: {%qz bytes %}. Anführungszeichen werden als " maskiert.
• String: {%j str %} oder Byte slice: {%jz bytes %}. Es gibt keine Anführungszeichen.
• URL encoding: {%u str %}, {%uz bytes %}.
• {%v anything %}: Die Ausgabe entspricht fmt.Sprintf("%v", anything).

Sample Code

Schreiben Sie zuerst das Template:

{% func Types(a int, b float64, c []byte, d string) %}
  int: {%d a %}, float64: {%f.2 b %}, bytes: {%z c %}, string with quotes: {%q d %}, string without quotes: {%j d %}.
{% endfunc %}

Dann verwenden Sie es:

func main() {
  fmt.Println(templates.Types(1, 5.75, []byte{'a', 'b', 'c'}, "hello"))
}

Führen Sie es aus:

$ go run .

Ausgabeergebnis:

int: 1, float64: 5.75, bytes: abc, string with quotes: "hello", string without quotes: hello.

Calling Functions

quicktemplate unterstützt das Aufrufen von Template-Funktionen und Funktionen aus der Standardbibliothek innerhalb von Templates. Da qtc direkt Go-Code generiert, können wir sogar unsere eigenen Funktionen im selben Verzeichnis schreiben, damit die Templates sie aufrufen können. Funktionen, die in Template A definiert sind, können auch Funktionen aufrufen, die in Template B definiert sind.

Define Custom Functions

Zuerst schreiben wir eine Datei rank.go im Verzeichnis templates und definieren eine Funktion Rank, die eine Punktzahl entgegennimmt und eine Bewertung zurückgibt:

package templates

func Rank(score int) string {
  if score >= 90 {
    return "A"
  } else if score >= 80 {
    return "B"
  } else if score >= 70 {
    return "C"
  } else if score >= 60 {
    return "D"
  } else {
    return "E"
  }
}

Call Custom Functions in Templates

Dann können wir diese Funktion im Template aufrufen:

{% import "fmt" %}
{% func ScoreList(name2score map[string]int) %}
  {% for name, score := range name2score %}
    {%s fmt.Sprintf("%s: score-%d rank-%s", name, score, Rank(score)) %}
  {% endfor %}
{% endfunc %}

Compile and Use the Template

Kompilieren Sie das Template:

$ qtc

Schreiben Sie das Programm:

func main() {
  name2score := make(map[string]int)
  name2score["leapcell"] = 85
  name2score["bob"] = 86
  name2score["alice"] = 22

  fmt.Println(templates.ScoreList(name2score))
}

Führen Sie das Programm aus und geben Sie Folgendes aus:

$ go run .

Ausgabeergebnis:

leapcell: score-85 rank-B
bob: score-86 rank-A
alice: score-22 rank-E

Da wir das Paket fmt im Template verwenden, müssen wir das Paket zuerst mit {% import %} importieren. Das Aufrufen von Funktionen eines anderen Templates in einem Template ist ähnlich, da Templates schließlich in Go-Code konvertiert werden und es Funktionen mit derselben Signatur im Go-Code gibt.

Web Applications

quicktemplate wird oft verwendet, um Templates für HTML-Seiten zu schreiben:

{% func Index(name string) %}
<html>
  <head>
    <title>Awesome Web</title>
  </head>
  <body>
    <h1>Hi, {%s name %}
    <p>Welcome to the awesome web!!!</p>
  </body>
</html>
{% endfunc %}

Schreiben Sie als Nächstes einen einfachen Webserver:

func index(w http.ResponseWriter, r *http.Request) {
  templates.WriteIndex(w, r.FormValue("name"))
}

func main() {
  mux := http.NewServeMux()
  mux.HandleFunc("/", index)

  server := &http.Server{
    Handler: mux,
    Addr:    ":8080",
  }

  log.Fatal(server.ListenAndServe())
}

qtc generiert eine Write*-Methode, die einen Parameter vom Typ io.Writer akzeptiert. Das Ergebnis des Renderns des Templates wird in diesen io.Writer geschrieben. Wir können http.ResponseWriter direkt als Parameter übergeben, was sehr praktisch ist.

Run the Web Server

$ qtc
$ go run .

Geben Sie localhost:8080?name=leapcell im Browser ein, um das Ergebnis anzuzeigen.

Conclusion

quicktemplate hat mindestens die folgenden drei Vorteile:

• The syntax is very similar to that of the Go language, with almost no learning cost.
• Die Syntax ähnelt sehr stark der der Go-Sprache, es entstehen fast keine Lernkosten.
• It will be converted into Go first, and the rendering speed is very fast, more than 20 times faster than the standard library html/template.
• Es wird zuerst in Go konvertiert, und die Rendering-Geschwindigkeit ist sehr hoch, mehr als 20-mal schneller als die Standardbibliothek html/template.
• For security reasons, it will perform some encoding to avoid being attacked.
• Aus Sicherheitsgründen führt es eine gewisse Codierung durch, um Angriffe zu vermeiden.

Leapcell: The Best of Serverless Web Hosting

Finally, I recommend to you a platform that is most suitable for deploying Go services: Leapcell

Endlich empfehle ich Ihnen eine Plattform, die sich am besten für die Bereitstellung von Go-Diensten eignet: Leapcell

🚀 Build with Your Favorite Language

Develop effortlessly in JavaScript, Python, Go, or Rust.

🚀 Mit Ihrer Lieblingssprache erstellen

Entwickeln Sie mühelos in JavaScript, Python, Go oder Rust.

🌍 Deploy Unlimited Projects for Free

Only pay for what you use—no requests, no charges.

🌍 Unbegrenzte Projekte kostenlos bereitstellen

Bezahlen Sie nur das, was Sie verbrauchen – keine Anfragen, keine Gebühren.

⚡ Pay-as-You-Go, No Hidden Costs

No idle fees, just seamless scalability.

⚡ Pay-as-You-Go, Keine versteckten Kosten

Keine Leerlaufgebühren, nur nahtlose Skalierbarkeit.

📖 Explore Our Documentation

📖 Entdecken Sie unsere Dokumentation

🔹 Follow us on Twitter: @LeapcellHQ