Text Templates

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#",
        })
}

$ go run templates.go 
Value: some text
Value: 5
Value: [Go Rust C++ C#]
Name: Jane Doe
Name: Mickey Mouse
yes 
no 
Range: Go Rust C++ C#