freeCodeCamp/guide/english/go/use-templates-with-your-webserver/index.md

title

title
Using templates with your web server

When you have a web server, you might want to insert data into your responses. Let's see some code:

package main

import (
  "net/http"
  "html/template"
)

type PAGE struct {
  NAME string
}

var page PAGE

func main() {
  page.NAME = "Mark"
  http.HandleFunc("/", servePage)
  http.ListenAndServe(":8080", nil)
}

func servePage(writer http.ResponseWriter, reqest *http.Request) {
  template := template.New("sayHello")
  template, _ = template.Parse("Hello {{.NAME}}!")
  template.Execute(writer, page)
}

Now fire up this program and navigate your browser to:

http://localhost:8080/

The response will be:

Hello Mark!

But how does this work and what does the code do? Well, first of all we import the net/http package so we can run a web server. Then we import the html/template package. This enables a feature called templating; and that is where this article is about.

We also create a type called PAGE, which has one field called NAME as type string. We also create a global variable called page of type PAGE, the struct we just created. In the main function we give the NAME field of page a value of Mark - my name, but feel free to use your own name!

The servePage function is a bit difficult at first. Let's take it apart:

func servePage(writer http.ResponseWriter, reqest *http.Request) {

  // 1. Creating a template
  template := template.New("sayHello")

  // 2. Filling the template
  template, _ = template.Parse("Hello {{.NAME}}!")

  // 3. Executing the template
  template.Execute(writer, page)
}

What do we do here? Let's see step by step:

1. We create a template. You need to enter a name, but it does not really matter what name you choose. Here I chose sayHello.
2. Then we fill the template with some text. Please take note of the {{.NAME}}.
3. Finally, we execute the template. This means that the template is filled out and sent to the client.

But how do we go from {{.NAME}} to Mark? Well, remember we used the page variable as a parameter to the Execute method? This method looks at the data in the template and sees {{.NAME}}. The .NAME indicates that it should look for a field called NAME inside the variable that was specified as a parameter when Execute was called. In this case it finds that field and it takes note of that the value is Mark. The {{ and }} are telling Execute that it should replace {{.NAME}} with the value that it found. So the end result will become Hello Mark!.

You can have multiple fields and multiple {{.XXX}}'s. This is a really easy way you can insert data into responses, and you now know how to template in Go!