105 lines
2.8 KiB
Go
105 lines
2.8 KiB
Go
// Go offers built-in support for creating
|
|
// dynamic content or showing customized output to the user called Template.
|
|
|
|
package main
|
|
|
|
// Go has two template packages. one is "text/template" for
|
|
// regular text manipulation, and another one is "html/template"
|
|
// mostly used in web applications.
|
|
// Here we show some of "text/template" features.
|
|
import (
|
|
"os"
|
|
"text/template"
|
|
)
|
|
|
|
func main() {
|
|
|
|
// New creates a template with a specific name and returns a pointer to it.
|
|
t := template.New("my-template")
|
|
|
|
// Parse parses its parameter as template body.
|
|
// We use {{.}} to access the value passed to the template when it's getting executed.
|
|
t, _ = t.Parse("Value is {{.}}\n")
|
|
|
|
// If we want to ignore the errors we can use Must function.
|
|
// It will panic if an error occurs when parsing the template.
|
|
t = template.Must(t.Parse("Value is {{.}}\n"))
|
|
|
|
// Execute applies parsed template to the data we pass to it and writes the output to the io.Writer.
|
|
t.Execute(os.Stdout, t.Name())
|
|
t.Execute(os.Stdout, "some text")
|
|
t.Execute(os.Stdout, true)
|
|
t.Execute(os.Stdout, 5)
|
|
t.Execute(os.Stdout, []string{
|
|
"Go",
|
|
"Rust",
|
|
"C++",
|
|
"C#",
|
|
})
|
|
t.Execute(os.Stdout, struct{ name string }{
|
|
name: "Arash",
|
|
})
|
|
|
|
// 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 template is executing.
|
|
t, _ = t.Parse("Firstname: {{.Firstname}}" +
|
|
", Lastname: {{.Lastname}}\n")
|
|
|
|
t.Execute(os.Stdout, struct {
|
|
Firstname, Lastname string
|
|
}{
|
|
Firstname: "Arash",
|
|
Lastname: "Sameni",
|
|
})
|
|
|
|
// Samething applies for maps. But it's not necessary to have uppercase fields.
|
|
t.Execute(os.Stdout, map[string]string{
|
|
"Firstname": "Robert",
|
|
"Lastname": "Griesemer",
|
|
})
|
|
|
|
// You can use if control structure to show data conditionally.
|
|
// The data between if block will be shown if the field is truthy.
|
|
// Means it is not false boolean, empty string, nil or zero length slice, nil map/pointer.
|
|
t, _ = t.Parse(`{{if .Field1}}
|
|
If block => {{.Field1}}
|
|
{{ else if .Field2}}
|
|
Else if block => {{.Field2}}
|
|
{{ else }}
|
|
Else block
|
|
{{ end }}`)
|
|
|
|
s := struct {
|
|
Field1, Field2 interface{}
|
|
}{}
|
|
|
|
s.Field1 = ""
|
|
s.Field2 = []string{}
|
|
t.Execute(os.Stdout, s)
|
|
|
|
s.Field1 = nil
|
|
s.Field2 = "Some text"
|
|
t.Execute(os.Stdout, s)
|
|
|
|
// Using a range action you can loop through a slice.
|
|
// Each time the range block is getting executed dot will be set
|
|
// to current item of slice.
|
|
// You can use $ in blocks to access outside data.
|
|
t, _ = t.Parse(`Range: {{ range . }}
|
|
{{.}}
|
|
{{ end }}`)
|
|
t.Execute(os.Stdout, []string{
|
|
"Go",
|
|
"Rust",
|
|
"C++",
|
|
"C#",
|
|
})
|
|
|
|
// You can assign and reassign a value to a variable in templates.
|
|
t, _ = t.Parse(`Variables: {{ $language := "go" }}
|
|
{{ $language }}
|
|
{{ $language = "C" }}
|
|
{{ $language }}`)
|
|
t.Execute(os.Stdout, nil)
|
|
}
|