Using the html/template Package in Go

Table of Contents

  1. Introduction
  2. Prerequisites
  3. Setup
  4. Creating HTML Templates
  5. Executing Templates
  6. Passing Data to Templates
  7. Using Control Structures
  8. Conclusion

Introduction

Welcome to this tutorial on using the html/template package in Go! The html/template package allows you to generate HTML output by combining predefined templates with data. This tutorial will guide you through the process of creating and executing templates, passing data to templates, and using control structures within templates. By the end of this tutorial, you will be able to create dynamic HTML pages using Go and the html/template package.

Prerequisites

To follow along with this tutorial, you should have a basic understanding of the Go programming language and its syntax. It would be beneficial to have some knowledge of HTML as well.

Setup

Before we can start using the html/template package, make sure you have Go installed on your machine. You can download and install Go by following the official installation guide at https://golang.org/doc/install.

Once Go is installed, create a new Go module for our project. Open a terminal and navigate to the directory where you want to create the module, then run the following command:

go mod init myapp

This command initializes a new Go module named myapp.

Now that our project is set up, let’s dive into using the html/template package!

Creating HTML Templates

To create an HTML template, we use a combination of Go’s text/template package and HTML syntax. HTML templates are Go template files with the .tmpl extension.

Create a new file named template.tmpl in your project directory, and let’s create a simple HTML template:

<!-- template.tmpl -->
<!DOCTYPE html>
<html>
<head>
    <title>{{.Title}}</title>
</head>
<body>
    <h1>{{.Heading}}</h1>
    <p>Welcome to my website!</p>
</body>
</html>

In this example, we have defined a basic HTML structure with placeholders ({{.Title}} and {{.Heading}}) for dynamic content.

Executing Templates

Now that we have a template, let’s write code to execute it and generate HTML output.

Create a new file named main.go and add the following code:

package main

import (
	"html/template"
	"os"
)

func main() {
	data := struct {
		Title   string
		Heading string
	}{
		Title:   "My Website",
		Heading: "Welcome to Go Templates!",
	}

	tmpl, err := template.ParseFiles("template.tmpl")
	if err != nil {
		panic(err)
	}

	err = tmpl.Execute(os.Stdout, data)
	if err != nil {
		panic(err)
	}
}

In this code, we create a struct data to hold the dynamic content values. We then parse the template file using template.ParseFiles(), passing in the filename as an argument. If there is an error during parsing, we panic.

Finally, we call tmpl.Execute() to execute the template and provide the output to os.Stdout. If there is an error during execution, we panic.

To run the code, open a terminal, navigate to your project directory, and run the following command:

go run main.go

You should see the generated HTML output in the terminal, which matches our template.

Passing Data to Templates

In the previous example, we passed data to the template using a struct. However, you can pass any Go value or object to the template.

Let’s update our main.go file to pass a slice of strings to the template:

package main

import (
	"html/template"
	"os"
)

func main() {
	data := struct {
		Title   string
		Heading string
		Languages []string
	}{
		Title:   "My Website",
		Heading: "Welcome to Go Templates!",
		Languages: []string{"Go", "Python", "JavaScript"},
	}

	tmpl, err := template.ParseFiles("template.tmpl")
	if err != nil {
		panic(err)
	}

	err = tmpl.Execute(os.Stdout, data)
	if err != nil {
		panic(err)
	}
}

In the template, we can access the Languages field and range over it to display each language:

<!-- template.tmpl -->
<!DOCTYPE html>
<html>
<head>
    <title>{{.Title}}</title>
</head>
<body>
    <h1>{{.Heading}}</h1>
    <h3>Languages:</h3>
    <ul>
        {{range .Languages}}
        <li>{{.}}</li>
        {{end}}
    </ul>
</body>
</html>

When you run the code again, you will see a list of languages added to the output.

Using Control Structures

The html/template package allows us to use control structures like conditionals and loops within templates.

Let’s modify our template to conditionally display additional content based on a boolean field:

<!-- template.tmpl -->
<!DOCTYPE html>
<html>
<head>
    <title>{{.Title}}</title>
</head>
<body>
    <h1>{{.Heading}}</h1>
    {{if .ShowMessage}}
    <p>Welcome to my website!</p>
    {{else}}
    <p>Website under construction.</p>
    {{end}}
</body>
</html>

In our main.go file, we can update the data struct to include the ShowMessage field:

data := struct {
    Title       string
    Heading     string
    ShowMessage bool
}{
    Title:       "My Website",
    Heading:     "Welcome to Go Templates!",
    ShowMessage: false,
}

By setting ShowMessage to true or false, we can control which part of the template is rendered.

Feel free to explore more control structures and apply them to your templates as needed.

Conclusion

In this tutorial, we learned how to use the html/template package in Go to generate dynamic HTML content. We covered the basics of creating templates, executing them with data, passing data to templates, and using control structures within templates. This knowledge can be applied in creating web applications or generating dynamic HTML pages in a variety of contexts.

Remember, the html/template package is just one piece of the Go language’s extensive standard library. As you continue your journey with Go, be sure to explore other powerful packages and utilize the language’s rich capabilities. Happy coding!

Published:

Related Articles