Introduction

Go's templating system allows you to create dynamic web pages by rendering data within HTML templates. In this guide, we'll explore Go templating, including the use of the "html/template" package, and provide sample code to demonstrate how to create dynamic web pages with Go.


The "html/template" Package

The "html/template" package is part of Go's standard library and provides a simple and secure way to generate HTML and other text-based formats. It supports the injection of dynamic data into templates using placeholders.


Basic Templating

Let's start with a simple example of using the "html/template" package to create a dynamic web page. In this example, we have a template that includes placeholders for dynamic content:

                            package main
                import (
                    "html/template"
                    "os"
                )
                func main() {
                    tmpl, _ := template.New("example").Parse("Hello, {{.}}!")
                    tmpl.Execute(os.Stdout, "World")
                }

In this code, we create a template with a placeholder "{{.}}" and use "Execute" to render the template with the value "World." The result is "Hello, World!".


Passing Data to Templates

You can pass data to templates by defining a struct or a map and then using the data in the template. Here's an example of passing a struct to a template:

                            package main
                import (
                    "html/template"
                    "os"
                )
                type Person struct {
                    Name string
                }
                func main() {
                    person := Person{Name: "Alice"}
                    tmpl, _ := template.New("example").Parse("Hello, {{.Name}}!")
                    tmpl.Execute(os.Stdout, person)
                }

In this code, we create a "Person" struct, pass it to the template, and access the "Name" field within the template.


Looping and Conditional Logic

Go templates support looping and conditional logic. Here's an example of looping through a list of names and rendering them in an HTML list:

                            package main
                import (
                    "html/template"
                    "os"
                )
                type Person struct {
                    Name string
                }
                func main() {
                    people := []Person{
                        {Name: "Alice"},
                        {Name: "Bob"},
                        {Name: "Charlie"},
                    }
                    tmpl, _ := template.New("example").Parse(`
                        <ul>
                            {{range .}}
                                <li>{{.Name}}</li>
                            {{end}}
                        </ul>
                    `)
                    tmpl.Execute(os.Stdout, people)
                }

In this code, we define a slice of "Person" structs, use the "range" directive in the template to loop through the list, and render each name as an HTML list item.


Further Resources

To continue learning about Go templating, consider these resources: