The entire Go language specification can be found online at https://golang.org/ref/spec. Much of the information in this chapter comes from the specification, as this is the one true documentation of the language. The rest of the information here is short examples, tips, best practices, and other things that I have learned during my time with Go.

The Go playground is a website where you can write and execute Go code without having to install anything. In the playground, https://play.golang.org, you can test pieces of code to explore the language and fiddle with things to understand how the language works. It also allows you to share your snippet by creating a unique URL that stores your snippet. Sharing code through the playground can be much more helpful than a plaintext snippet, since it allows the reader to actually execute the code and tinker with the source if they have any questions about how it works:

The preceding screenshot shows a simple program being run in the playground. There are buttons at the top to run, format, add import statements, and share the code with others.

Another resource provided by the Go team is A Tour of Go. This website, https://tour.golang.org, is built on top of the playground mentioned in the previous section. The tour was my first introduction to the language, and when I completed it, I felt well-equipped to start tackling projects in Go. It walks you through the language step by step along with working code examples so that you can run and modify the code to get familiar with the language. It is a practical way to introduce a newcomer to Go. If you have never used Go at all, I encourage you to check it out.

The preceding screenshot shows the first page of the tour. On the right-hand side, you will have a small embedded playground with the code sample relevant to the short lesson shown on the left-hand side. Each lesson comes with a short code example that you can run and tinker with.

To emphasize how simple Go is, here is a breakdown of all its 25 keywords. You probably already know most of them if you are familiar with other programming languages. The keywords are grouped together to examine them according to their use.

Data types:

Functions:

Packages:

Program flow:

Go source code files should have the .go extension. The source code of Go files is encoded in UTF-8 Unicode. This means that you can use any Unicode characters in your code, like hardcoding Japanese characters in a string.

Semicolons are optional at the end of a line and typically omitted. Semicolons are only required when separating multiple statements or expressions on a single line.

Go does have a code formatting standard which can easily be adhered to by running go fmt on source code files. The code formatting should be followed, but it is not strictly enforced by the compiler the way Python requires exact formatting to execute properly.

Comments follow a C++ style allowing the double slash and the slash-asterisk wrapped style:

// Line comment, everything after slashes ignored
/* General comment, can be in middle of line or span multiple lines */

The built-in data types are named intuitively enough. Go comes with a set of integer and unsigned integer types with varying bit lengths. There are also floating point numbers, Booleans, and strings, which should come as no surprise.

There are a few types like runes that are not common in other languages. This section covers all of the different types.

The Boolean type represents a true or false value. Some languages don't provide a bool type, and you have to use an integer or define your own enumeration, but Go conveniently comes with a predeclared bool type. The true and false constants are also predefined and used in all lowercase. Here is an example of creating a Boolean:

var customFlag bool = false...

Control structures are used to control the flow of program execution. The most common forms are the if statements, for loops, and switch statements. Go also supports the goto statement, but should be reserved for cases of extreme performance and not used regularly. Let's look briefly at each of these to understand the syntax.

The if statement comes with the if, else if, and else clauses, just like most other languages. The one interesting feature that Go has is the ability to put a statement before the condition, creating temporary variables that are discarded after the if statement has completed.

This example demonstrates the various ways to use an if statement:

package main

import (
   "fmt...

By deferring a function, it will run whenever the current function is exited. This is a convenient way to ensure that a function will get executed before exiting, which is useful for cleaning up or closing files. It is convenient because a deferred function will get executed no matter where the surrounding function exits if there are multiple return locations.

Common use cases are deferring calls to close a file or database connection. Right after opening a file, you can defer a call to close. This will ensure that a file is closed whenever the function is exited, even if there are multiple return statements and you can't be sure about when and where the current function will exit.

This example demonstrates a simple use case for the defer keyword. It creates a file and then defers a call to file.Close():

package main

import (
   "log"
   "os"
)

func main...

Packages are just directories. Every directory is its own package. Creating subdirectories creates a new package. Having no subpackages leads to a flat hierarchy. Subdirectories are used just for organizing code.

Packages should be stored in the src folder of your $GOPATH variable.

A package name should match the folder name or be named main. A main package means that it is not intended to be imported into another application, but meant to compile and run as a program. Packages are imported using the import keyword.

You can import packages individually:

import "fmt" 

Alternatively, you can import multiple packages at once by wrapping them with parenthesis:

import (
   "fmt"
   "log"
) 

Go technically does not have classes, but there are only a few subtle distinctions that keep it from being called an object-oriented language. Conceptually, I do consider it an object-oriented programming language, though it only supports the most basic features of an object-oriented language. It does not come with all of the features many people have come to associate with object-oriented programming, such as inheritance and polymorphism, which are replaced with other features such as embedded types and interfaces. Perhaps you could call it a microclass system, because it is a minimalistic implementation with none of the extra features or baggage, depending on your perspective.

Throughout this book, the terms object and class may be used to illustrate a point using familiar terms, but be aware that these are not formal terms in Go. A type definition in combination with...

Goroutines are lightweight threads built into the language. You simply have to put the word go in front of a function call to have the function execute in a thread. Goroutines may also be referred to as threads in this book.

Go does provide mutexes, but they are avoidable in most cases and will not be covered in this book. You can read more about mutexes in the sync package documentation at https://golang.org/pkg/sync/. Channels should be used instead for sharing data and communicating between threads. Channels were covered earlier in this chapter.

Note that the log package is safe to use concurrently, but the fmt package is not. Here is a short example of using goroutines:

package main

import (
   "log"
   "time"
)

func countDown() {
   for i := 5; i >= 0; i-- {
      log.Println(i)
      time.Sleep(time.Millisecond * 500)
   }
}

func main() {
   // Kick...

Go has both online and offline help documentation. The offline documentation is built-in for Go and is the same documentation that is hosted online. These next sections will walk you through accessing both forms of documentation.

The online documentation is available at https://golang.org/, and has all the formal documentation, specifications, and help files. Language documentation specifically is at https://golang.org/doc/, and information about the standard library is at https://golang.org/pkg/.

After reading this chapter you should have a basic understanding of Go fundamentals such as what the keywords are, what they do, and what basic data types are available. You should also feel comfortable creating functions and custom data types.

The goal is not to memorize all of the preceding information, but to be aware of what tools are available in the language. Use this chapter as a reference if necessary. You can find more information about the Go language specification at https://golang.org/ref/spec.

In the next chapter, we will look at working with files in Go. We will cover basics such as getting file information, seeing whether a file exists, truncating files, checking permissions, and creating new files. We will also cover the reader and writer interfaces, as well as a number of ways to read and write data. In addition to this, we will cover things such as archiving...