84 lines
2.4 KiB
Go
84 lines
2.4 KiB
Go
// Go offers built-in support for creating dynamic content or showing customized
|
|
// output to the user with the `text/template` package. A sibling package
|
|
// named `html/template` provides the same API but has additional security
|
|
// features and should be used for generating HTML.
|
|
|
|
package main
|
|
|
|
import (
|
|
"os"
|
|
"text/template"
|
|
)
|
|
|
|
func main() {
|
|
|
|
// We can create a new template and parse its body from
|
|
// a string.
|
|
// Templates are a mix of static text and "actions" enclosed in
|
|
// `{{...}}` that are used to dynamically insert content.
|
|
t1 := template.New("t1")
|
|
t1, err := t1.Parse("Value is {{.}}\n")
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
// Alternatively, we can use the `template.Must` function to
|
|
// panic in case `Parse` returns an error. This is especially
|
|
// useful for templates initialized in the global scope.
|
|
t1 = template.Must(t1.Parse("Value: {{.}}\n"))
|
|
|
|
// By "executing" the template we generate its text with
|
|
// specific values for its actions. The `{{.}}` action is
|
|
// replaced by the value passed as a parameter to `Execute`.
|
|
t1.Execute(os.Stdout, "some text")
|
|
t1.Execute(os.Stdout, 5)
|
|
t1.Execute(os.Stdout, []string{
|
|
"Go",
|
|
"Rust",
|
|
"C++",
|
|
"C#",
|
|
})
|
|
|
|
// Helper function we'll use below.
|
|
Create := func(name, t string) *template.Template {
|
|
return template.Must(template.New(name).Parse(t))
|
|
}
|
|
|
|
// If the data is a struct we can use the `{{.FieldName}}` action to access
|
|
// its fields. The fields should be exported to be accessible when a
|
|
// template is executing.
|
|
t2 := Create("t2", "Name: {{.Name}}\n")
|
|
|
|
t2.Execute(os.Stdout, struct {
|
|
Name string
|
|
}{"Jane Doe"})
|
|
|
|
// The same applies to maps; with maps there is no restriction on the
|
|
// case of key names.
|
|
t2.Execute(os.Stdout, map[string]string{
|
|
"Name": "Mickey Mouse",
|
|
})
|
|
|
|
// if/else provide conditional execution for templates. A value is considered
|
|
// false if it's the default value of a type, such as 0, an empty string,
|
|
// nil pointer, etc.
|
|
// This sample demonstrates another
|
|
// feature of templates: using `-` in actions to trim whitespace.
|
|
t3 := Create("t3",
|
|
"{{if . -}} yes {{else -}} no {{end}}\n")
|
|
t3.Execute(os.Stdout, "not empty")
|
|
t3.Execute(os.Stdout, "")
|
|
|
|
// range blocks let us loop through slices, arrays, maps or channels. Inside
|
|
// the range block `{{.}}` is set to the current item of the iteration.
|
|
t4 := Create("t4",
|
|
"Range: {{range .}}{{.}} {{end}}\n")
|
|
t4.Execute(os.Stdout,
|
|
[]string{
|
|
"Go",
|
|
"Rust",
|
|
"C++",
|
|
"C#",
|
|
})
|
|
}
|