Setting the Scene

In this chapter, I create a Go project and use it to create a simple application that contains all these features.

Installing the Development Tools

The first step is to install the Go development tools. Go to https://golang.org/dl and download the installation file for your operating system. Installers are available for Windows, Linux, and macOS. Follow the installation instructions, which can be found at https://golang.org/doc/install, for your platform. When you have completed the installation, open a command prompt and run the command shown in Listing 1-1, which will confirm that the Go tools have been installed by printing out the package version.

Creating the Project

The go command is used for almost every development task, as I explain in Chapter 3. This command creates a file named go.mod, which is used to keep track of the packages a project depends on and can also be used to publish the project, if required.

The syntax of Go will be familiar if you have used any C or C-like language, such as C# or Java. I describe the Go language in depth in this book, but you can discern a lot just by looking at the keywords and structure of the code in Listing 1-3.

Features are grouped into packages, which is why there is a package statement in Listing 1-3. Dependencies on packages are made using an import statement, which allows the features they use to be accessed in a code file. Statements are grouped in functions, which are defined with the func keyword. There is one function in Listing 1-3, which is named main. This is the entry point for the application, meaning that this is the point at which execution will begin when the application is compiled and run.

The main function contains a single code statement, which invokes a function named Println, which is provided by a package named fmt. The fmt package is part of the extensive standard library that Go provides, described in Part 2 of this book. The Println function prints out a string of characters.

Go insists on a specific code style and deals with common code elements, such as semicolons, in unusual ways. The details of the Go syntax are described in later chapters, but, for now, it is important to follow the examples exactly as shown to avoid errors.

Defining a Data Type and a Collection

Go allows custom types to be defined and given a name using the type keyword. Listing 1-6 creates a struct data type named Rsvp. Structs allow a set of related values to be grouped together. The Rsvp struct defines four fields, each of which has a name and a data type. The data types used by the Rsvp fields are string and bool, which are the built-in types for representing a string of characters and Boolean values. (The Go built-in types are described in Chapter 4.)

Next, I need to collect Rsvp values together. In later chapters, I explain how to use a database in a Go application, but for this chapter, it will be enough to store the responses in memory, which means that responses will be lost when the application is stopped.

This new statement relies on several Go features, which are most readily understood by starting at the end of the statement and working backwards.

I specified zero for the size argument create an empty slice. Slices are resized automatically as new items are added, and the initial capacity determines how many items can be added before the slice has to be resized. In this case, ten items can be added to the slice before it has to be resized.

The square brackets, [], denote a slice. The asterisk, *, denotes a pointer. The Rsvp part of the type denotes the struct type defined in Listing 1-6. Put together, []*Rsvp denotes a slice of pointers to instances of the Rsvp struct.

You may have flinched at the term pointer if you have arrived at Go from C# or Java, which do not allow pointers to be used directly. But you can relax because Go doesn’t allow the types of operations on pointers that can get a developer into trouble. As I explain in Chapter 4, the use of pointers in Go determines only whether a value is copied when it is used. By specifying that my slice will contain pointers, I am telling Go not to create copies of my Rsvp values when I add them to the slice.

The var keyword indicates that I am defining a new variable, which is given the name responses. The equal sign, =, is the Go assignment operator and sets the value of the responses variable to the newly created slice. I don’t have to specify the type of the responses variable because the Go compiler will infer it from the value that is assigned to it.

Creating HTML Templates

This template will be a layout that contains the content common to all of the responses that the application will produce. It defines a basic HTML document, including a link element that specifies a stylesheet from the Bootstrap CSS framework, which will be loaded from a content distribution network (CDN). I demonstrate how to serve this file from a folder in Chapter 24, but I have used the CDN for simplicity in this chapter. The example application will still work offline, but you will see HTML elements without the styles shown in the figures.

The double curly braces in Listing 1-8, {{ and }}, are used to insert dynamic content into the output produced by the template. The block expression used here defines placeholder content that will be replaced by another template at runtime.

Creating the HTTP Handlers and Server

The second argument is a pointer to an instance of the Request struct, defined in the net/http package, which describes the request being processed. The first argument is an example of an interface, which is why it isn’t defined as a pointer. Interfaces specify a set of methods that any struct type can implement, allowing code to be written to make use of any type that implements those methods, which I explain in detail in Chapter 11.

One of the most commonly used interfaces is Writer, which is used everywhere data can be written, such as files, strings, and network connections. The ResponseWriter type adds additional features that are specific to dealing with HTTP responses.

This statement reads the *template.Template from the map assigned to the templates variable and invokes the Execute method it defines. The first argument is the ResponseWriter, which is where the output from the response will be written, and the second argument is a data value that can be used in the expressions contained in the template.

Open a new web browser and request the URL http://localhost:5000, which will produce the response shown in Figure 1-1. (If you are using Windows, you may be prompted for approval by the Windows firewall before requests can be processed by the server. You will need to grant approval every time you use the go run . command in this chapter. Later chapters introduce a simple PowerShell script to address this issue.)

Press Ctrl+C to stop the application once you have confirmed that it can produce a response.

Writing the Form Handling Function

The result is that the formData struct can be used as though it defines the Name, Email, Phone, and WillAttend fields from the Rsvp struct and that I can create an instance of the formData struct using an existing Rsvp value. The asterisk denotes a pointer, which means that I don’t want to copy the Rsvp value when I create the formData value.

Open a new web browser, request the URL http://localhost:5000, and click the RSVP Now button. The new handler will receive the request from the browser and display the HTML form shown in Figure 1-2.

Handling the Form Data

Now I need to handle POST requests and read the data that the user has entered into the form, as shown in Listing 1-21. This listing shows only the changes to the formHandler function; the rest of the main.go file remains unchanged.

...

func formHandler(writer http.ResponseWriter, request *http.Request) {

    if request.Method == http.MethodGet {

        templates["form"].Execute(writer, formData {

            Rsvp: &Rsvp{}, Errors: []string {},

        })

    } else if request.Method == http.MethodPost {

        request.ParseForm()

        responseData := Rsvp {

            Name: request.Form["name"][0],

            Email: request.Form["email"][0],

            Phone: request.Form["phone"][0],

            WillAttend: request.Form["willattend"][0] == "true",

        }

        responses = append(responses, &responseData)

        if responseData.WillAttend {

            templates["thanks"].Execute(writer, responseData.Name)

        } else {

            templates["sorry"].Execute(writer, responseData.Name)

        }

    }

}

...

Listing 1-21

Handling Form Data in the main.go File in the partyinvites Folder

The ParseForm method processes the form data contained in an HTTP request and populates a map, which can be accessed through the Form field. The form data is then used to create an Rsvp value:

...

responseData := Rsvp {

    Name: request.Form["name"][0],

    Email: request.Form["email"][0],

    Phone: request.Form["phone"][0],

    WillAttend: request.Form["willattend"][0] == "true",

}

...

This statement demonstrates how a struct is instantiated with values for its fields, as opposed to the default values that were used in Listing 1-19. HTML forms can include multiple values with the same name, so the form data is presented as a slice of values. I know that there will be only one value for each name, and I access the first value in the slice using the standard zero-based index notation that most languages use.

Once I have created an Rsvp value, I add it to the slice assigned to the responses variable:

...

responses = append(responses, &responseData)

...

The append function is used to append a value to a slice. Notice that I use the ampersand to create a pointer to the Rsvp value I created. If I had not used a pointer, then my Rsvp value would be duplicated when it is added to the slice.

The remaining statements use the value of the WillAttend field to select the template that will be presented to the user.

Run the command shown in Listing 1-22 in the partyinvites folder to compile and execute the project.

go run .

Listing 1-22

Compiling and Executing the Project

Open a new web browser, request the URL http://localhost:5000, and click the RSVP Now button. Fill out the form and click the Submit RSVP button; you will receive a response selected based on which value you chose using the HTML select element. Click the link in the response to see a summary of the responses the application has received, as shown in Figure 1-3.

Adding Data Validation

The application will receive an empty string ("") from the request when the user doesn’t provide a value for a form field. The new statements in Listing 1-23 check the Name, Email, and Phone fields and add a message to a slice of strings for each field that doesn’t have a value. I use the built-in len function to get the number of values in the errors slice, and if there are errors, then I render the contents of the form template again, including the error messages in the data the template receives. If there are no errors, then the thanks or sorry template is used.

Open a new web browser, request the URL http://localhost:5000, and click the RSVP Now button. Click the Submit RSVP button without entering any values into the form; you will see warning messages, as shown in Figure 1-4. Enter some details into the form and submit it again, and you will see the final message.

Summary

In this chapter, I installed the Go package and used the tools it contains to create a simple web application using only a single code file and some basic HTML templates. Now that you have seen Go in action, the next chapter puts this book into context.