4.2 KiB
Sure! Let's break down the concept of actions in Go templates, represented by {{ ... }}, with examples for each type: variables, function calls, loops, conditionals, and more.
1. Variables
In Go templates, variables are placeholders that get replaced with actual data when the template is rendered. The data is typically passed to the template from the Go code.
Example:
{{ .Title }}
Here, {{ .Title }} will be replaced by the value of the Title field in the data passed to the template.
Go Code:
data := struct {
Title string
}{
Title: "Welcome to My Website",
}
tmpl.Execute(w, data)
Template:
<!DOCTYPE html>
<html>
<head>
<title>{{ .Title }}</title>
</head>
<body>
<h1>{{ .Title }}</h1>
</body>
</html>
2. Function Calls
Go templates allow you to call functions to process data before rendering it. Built-in functions can be used directly in the template.
Example:
{{ .Date | dateFormat "2006-01-02" }}
Here, {{ .Date | dateFormat "2006-01-02" }} formats the date using the dateFormat function.
Go Code:
data := struct {
Date time.Time
}{
Date: time.Now(),
}
tmpl.Execute(w, data)
Template:
<!DOCTYPE html>
<html>
<head>
<title>Date Example</title>
</head>
<body>
<p>{{ .Date | dateFormat "2006-01-02" }}</p>
</body>
</html>
3. Loops
Loops allow you to iterate over collections like arrays or slices.
Example:
{{ range .Items }}
<li>{{ . }}</li>
{{ end }}
Here, {{ range .Items }} loops through each item in the Items collection.
Go Code:
data := struct {
Items []string
}{
Items: []string{"Item 1", "Item 2", "Item 3"},
}
tmpl.Execute(w, data)
Template:
<!DOCTYPE html>
<html>
<head>
<title>Loop Example</title>
</head>
<body>
<ul>
{{ range .Items }}
<li>{{ . }}</li>
{{ end }}
</ul>
</body>
</html>
4. Conditionals
Conditionals are used to include or exclude parts of the template based on certain conditions.
Example:
{{ if .IsAdmin }}
<p>Welcome, admin!</p>
{{ else }}
<p>Welcome, user!</p>
{{ end }}
Here, {{ if .IsAdmin }} checks if the IsAdmin variable is true.
Go Code:
data := struct {
IsAdmin bool
}{
IsAdmin: true,
}
tmpl.Execute(w, data)
Template:
<!DOCTYPE html>
<html>
<head>
<title>Conditional Example</title>
</head>
<body>
{{ if .IsAdmin }}
<p>Welcome, admin!</p>
{{ else }}
<p>Welcome, user!</p>
{{ end }}
</body>
</html>
5. Pipelines
Pipelines allow you to chain multiple operations together. Each operation's output becomes the input for the next operation.
Example:
{{ .Price | multiply 1.1 | printf "%.2f" }}
Here, {{ .Price | multiply 1.1 | printf "%.2f" }} multiplies Price by 1.1 and then formats it to two decimal places.
Go Code:
data := struct {
Price float64
}{
Price: 100.0,
}
tmpl.Execute(w, data)
Template:
<!DOCTYPE html>
<html>
<head>
<title>Pipeline Example</title>
</head>
<body>
<p>Price: ${{ .Price | multiply 1.1 | printf "%.2f" }}</p>
</body>
</html>
6. Custom Functions
You can define custom functions in Go and pass them to the template.
Example:
Define a custom function to multiply a number:
func multiply(a, b float64) float64 {
return a * b
}
Go Code:
func multiply(a, b float64) float64 {
return a * b
}
func main() {
tmpl := template.New("example").Funcs(template.FuncMap{
"multiply": multiply,
})
tmpl, _ = tmpl.Parse(`
<!DOCTYPE html>
<html>
<head>
<title>Custom Function Example</title>
</head>
<body>
<p>Price: ${{ .Price | multiply 1.1 }}</p>
</body>
</html>`)
data := struct {
Price float64
}{
Price: 100.0,
}
tmpl.Execute(os.Stdout, data)
}
Conclusion
Go templates use {{ ... }} to perform various actions, including accessing variables, calling functions, iterating over collections, and evaluating conditions. This flexibility allows you to create dynamic, data-driven content easily. Understanding these actions helps you utilize the full power of Go templates effectively.