Installation

If you know about installation or have installed Go, you can skip to Tools.

This chapter is taken from install page verbatim, except for the changes to be made to adapt to this book’s styling format.

System requirements

Go binary distributions are available for these supported operating systems and architectures. Please ensure your system meets these requirements before proceeding. If your OS or architecture is not on the list, you may be able to install from source or use gccgo instead

†gcc is required only if you plan to use cgo.

‡You only need to install the command line tools for Xcode. If you have already installed Xcode 4.3+, you can install it from the Components tab of the Downloads preferences panel.

Install the Go tools

If you are upgrading from an older version of Go you must first remove the existing version. Linux, Mac OS X, and FreeBSD tarballs

Download the archive and extract it into /usr/local, creating a Go tree in /usr/local/go. For example:

tar -C /usr/local -xzf go$VERSION.$OS-$ARCH.tar.gz

Choose the archive file appropriate for your installation. For instance, if you are installing Go version 1.2.1 for 64-bit x86 on Linux, the archive you want is called go1.2.1.linux-amd64.tar.gz.

(Typically these commands must be run as root or through sudo.)

Add /usr/local/go/bin to the PATH environment variable. You can do this by adding this line to your /etc/profile (for a system-wide installation) or $HOME/.profile:

export PATH=$PATH:/usr/local/go/bin

Installing to a custom location

The Go binary distributions assume they will be installed in /usr/local/go (or c:\Go under Windows), but it is possible to install the Go tools to a different location. In this case you must set the GOROOT environment variable to point to the directory in which it was installed.

For example, if you installed Go to your home directory you should add the following commands to $HOME/.profile:

export GOROOT=$HOME/go

export PATH=$PATH:$GOROOT/bin

Note: GOROOT must be set only when installing to a custom location.

Mac OS X package installer

Download the package file, open it, and follow the prompts to install the Go tools. The package installs the Go distribution to /usr/local/go.

The package should put the /usr/local/go/bin directory in your PATH environment variable. You may need to restart any open Terminal sessions for the change to take effect.

Windows

The Go project provides two installation options for Windows users (besides installing from source): a zip archive that requires you to set some environment variables and an MSI installer that configures your installation automatically.

MSI installer

Open the MSI file and follow the prompts to install the Go tools. By default, the installer puts the Go distribution in c:Go.

The installer should put the c:\Go\bin directory in your PATH environment variable. You may need to restart any open command prompts for the change to take effect.

Zip archive

Download the zip file and extract it into the directory of your choice (we suggest c:Go).

If you chose a directory other than c:\Go, you must set the GOROOT environment variable to your chosen path.

Add the bin subdirectory of your Go root (for example, c:\Go\bin) to your PATH environment variable.

Setting environment variables under Windows

Under Windows, you may set environment variables through the “Environment Variables” button on the “Advanced” tab of the “System” control panel. Some versions of Windows provide this control panel through the “Advanced System Settings” option inside the “System” control panel.

Test your installation

Check that Go is installed correctly by setting up a workspace and building a simple program, as follows.

Create a directory to contain your workspace, $HOME/work for example, and set the GOPATH environment variable to point to that location.

1 $ export GOPATH=$HOME/work

You should put the above command in your shell startup script ($HOME/.profile for example) or, if you use Windows, follow the instructions above to set the GOPATH environment variable on your system.

Next, make the directories src/github.com/user/hello inside your workspace (if you use GitHub, substitute your user name for user), and inside the hello directory create a file named hello.go with the following contents:

1     package main
2     
3     import "fmt"
4     
5     func main() {
6         fmt.Printf("hello, world\n")
7     }

Then compile it with the go tool:

1    $ go install github.com/user/hello

The above command will put an executable command named hello (or hello.exe) inside the bin directory of your workspace. Execute the command to see the greeting:

1     $ $GOPATH/bin/hello

hello, world

If you see the “hello, world” message then your Go installation is working.

Before rushing off to write Go code please read the How to Write Go Code document, which describes some essential concepts about using the Go tools.

Uninstalling Go

To remove an existing Go installation from your system delete the go directory. This is usually /usr/local/go under Linux, Mac OS X, and FreeBSD or c:\Go under Windows.

You should also remove the Go bin directory from your PATH environment variable. Under Linux and FreeBSD you should edit /etc/profile or $HOME/.profile. If you installed Go with the Mac OS X package then you should remove the /etc/paths.d/go file. Windows users should read the section about setting environment variables under Windows.

Getting help

For real-time help, ask the helpful gophers in #go-nuts on the Freenode IRC server.

The official mailing list for discussion of the Go language is Go Nuts.

Report bugs using the Go issue tracker.

Links

-Next section

Tools

HTML: Brackets, a text editor for the web by Adobe.

Go: Any IDE of your choice which has a Go language plugin.

The toolchain

The Go programming language comes with a set of tools along with the standard installation.

gofmt

Usage:

gofmt main.go : Prints the formatted source code of main.go file on the console.

gofmt -w main.go: Writes the formatted code in the file main.go

gofmt -w Tasks: Runs gofmt on all the files in the folder Tasks.

go fmt can be used in place of gofmt -w.

Most IDEs can be configured to run gofmt on save.

It is highly recommended to run gofmt before committing to version control.

godoc

It extracts documentation comments on all the Go projects present in $GOPATH/src, and the standard library present in $GOROOT.

It has two interfaces:

• Web:

  Usage: godoc -http=:6060

  The documentation of net/http is present at localhost:6060/pkg/net/http. godoc also allows users to read the Go source code of the packages. Since Go is now implemented in Go itself, we can read the source code of Go language.

Note: Verbose Flag

Depending on how much projects are in your $GOPATH, it’ll take time for godoc to get up and running, please use -v flag. Using the -v flag, we come to know when the server got up.

• Commandline:

  Usage: godoc net/http

  This will provide the documentation of net/http on the terminal, like the man command. The catch here is that we need to know the exact library name.

  The packages where comments aren’t present show up as blank pages in godoc.

Documentation

The documentation covered by godoc is the documentation about the API, since only the exported functions have documentation comments in godoc. This documentation is different from the logic documentation.

go test

Go has testing support built into the language. For each code file file.go, the corresponding test cases should be present in a file named as file_test.go in the same folder. The Go compiler ignores all the *_test.go files while building the application.

go build

We can build our application using go build. It parses all the .go files except the *_test.go files in the entire folder and all sub folders along with imported libraries if any, and creates a statically linked binary. The binary name is the same as the project folder name, if we want a custom name we should use the -o flag.

Example: go build -o tasks

Build time

By default, go build builds the entire application and the depending libraries, into a static binary and later throws all away. This results in rebuilding everything every single time go build is executed. For caching the library builds, use go install first and go build later.

Cross compilation

Go allows cross compilation. We have to pass the OS name as linux/darwin/windows as GOOS as shown in the below commands.

1 env GOOS=darwin GOARCH=386 go build -o tasks.app
2 env GOOS=windows GOARCH=386 go build -o tasks.exe

go install

Creates a statically linked binary and places it in $GOPATH/bin. Also creastes a .a file of the library and puts it in the $GOPATH/pkg folder. In future builds this library file will be reused until the underlying code is changed.

For using tools built with Go like we use unix commands, we need to add $GOPATH/bin to the environment variable $PATH.

Note: $PATH

On Linux/Unix the $PATH environment variable is a list of directories which are known to have executables. When we call some executable from any terminal, the shell goes through all folders present in $PATH one at a time until it finds the executable.

In Linux/Unix, this is done using: export PATH=$PATH:$GOPATH/bin. This line needs to be added to either .bashrc or .profile, whichever is being used by the shell.

The profile files are present in the home folder. Do a cd ~ and check for either of the files mentioned above.

go run

go run combines building and running the application in one command.

It generates a binary in the temp folder and executes it. The binary file isn’t retained after the run.

go get

This is the package manager in Go. It internally clones the version control repository parameter passed to it, can be any local/remote git repository. It then runs go install on the library, making the library available in $GOPATH/pkg. If the repository doesn’t have any buildable files then go get might complain, but that happens after the repository is cloned.

go clean

This command is for cleaning files that are generated by compilers, including the following files:

 1 _obj/            // old directory of object, left by Makefiles
 2 _test/           // old directory of test, left by Makefiles
 3 _testmain.go     // old directory of gotest, left by Makefiles
 4 test.out         // old directory of test, left by Makefiles
 5 build.out        // old directory of test, left by Makefiles
 6 *.[568ao]        // object files, left by Makefiles
 7 
 8 DIR(.exe)        // generated by go build
 9 DIR.test(.exe)   // generated by go test -c
10 MAINFILE(.exe)   // generated by go build MAINFILE.go

Other commands

Go provides more commands than those we’ve just talked about.

1 go fix // upgrade code from an old version before go1 to a new version after go1
2 go version // get information about your version of Go
3 go env // view environment variables about Go
4 go list // list all installed packages

For details about specific commands, go help <command>.

Links

-Previous section -Next section

Hello, Go

Why Go?

Go was built at Google, a company synonymous with Search and Distributed Computing, with Kubernetes. They wanted a language that was fast, worked well with automated code review and formatting and allowed a large team to write large scale software effectively, catered to the multi-core and networking era. All other major languages are at least a decade old. They were created in an era where memory was costly, where there were no massive clusters or multi-core processors.

When switching from other languages to Go, it’ll be more or less frustrating to see the restrictions Go has. But as you tag along, the nuisances pay off. The language takes care of other things like formatting, and its goal is to provide a scalable approach to build the application over a long period of time.

In the C family of languages, there are two factions:

1 public static void main() {
2 
3 }

vs

1 public static void main() 
2 {
3 
4 }

The same can be said of Python spaces/tabs.

Technically speaking, this was an unintended consequence of doing away with the semi colons, since the Go compiler adds semicolons at the end of each line, we can’t have the #2 definition in Go.

This might seem to be a shallow problem, but when the codebase and team size grows, then it is difficult to maintain the consistency because of different user preferences. Anyone can write code these days, few can write elegant code. Other languages had to solve this problem as an afterthought. In Go they have been built into the language. Go isn’t just a language, it is an ecosystem and it caters to the entire software development cycle.

It aims to provide the efficiency of a statically-typed compiled language with the ease of programming of a dynamic language.

A list of features:

1. Unused imports/variables are compiler errors.
2. Semi-colons not needed, the compiler adds them at the line end.
3. A folder $GOPATH, as it is called contains all your Go code.
4. There is only one standard way to write Go code, use gofmt.
5. Batteries included standard library.
6. Compiled language, thus very fast.
7. Webapps can be written without a framework.
8. Has concurrency built in, just attach the word go before a function call to run it in its own goroutine.
9. Supports Unicode.
10. No language change from 1.0 to 1.7

Let’s start with the customary Hello World.

First Program

1 package main
2 
3 import "fmt"
4 
5 func main() {
6 	fmt.Printf("Hello, world or καλημ ρα κóσμ\n")
7 }

It prints following information.

1 Hello, world or καλημ ρα κóσμ

Explanation

We import the format package, fmt for short. Write the main function of the main package and run the code. We can access only the Exported objects of any library in Go. Exported means that the names should start with a capital letter. The compiler will find the main function of the main package whenever we build or execute any Go code.

We printed non ASCII characters. Go supports UTF-8 by default.

The main package

It is mandatory for each Go program to be a part of a package. The package can be main or not.

Every package except main should be a distinct folder on the $GOPATH. Main is a special package for which having a folder on $GOPATH is optional.

Building applications differs when we have a main folder and when we don’t.

$GOPATH/src/github.com/thewhitetulip/Tasks

• main.go
• view.go

or

$GOPATH/src/github.com/thewhitetulip/Tasks

• main/main.go
• view.go

In scenarios like this, we need to understand two different ways of executing the application

• With the main folder:

  1       [Tasks] $ go build main/main.go
  2       [Tasks] $ ./main/main
  

This will function correctly, because we are in the Tasks directory while executing our binary, all the templates and other files are present in this folder.

• Without the main folder

  1       [Tasks/main] $ go build main.go
  2       [Tasks/main] $ ./main
  

Here, we are in the Tasks/main directory, the binary will expect all the other files in the Tasks/main directory when they are in the Tasks directory, one level up.

There can be only one main package & function per executable program. The main function takes no arguments passed and returns nothing.

Links

-Previous section -Next section

Variables & Data structures

Variables

We use the keyword var to define a variable. The variable type comes after the variable name.

 1 // define a variable with name "numberOfTimes" and type "int"
 2 // the examples are of int, but you can use any other data type.
 3 var numberOfTimes int
 4 
 5 // define three variables which types are "int"
 6 var var1, var2, var3 int
 7 
 8 // define a variable with name "numberOfTimes”, type "int" 
 9 // and value "3"
10 var numberOfTimes int = 3
11 
12 /*
13 Define three variables with type "int", and 
14 initialize their values.
15 var1 is 1, var2 is 2, var3 is 3.
16 */
17 var var1, var2, var3 int = 1, 2, 3

Variable declaration Shortcut

1 /*
2 Define three variables without type "type" and
3 without keyword "var", and initialize their values.
4 vname1 is v1，vname2 is v2，vname3 is v3
5 */
6 vname1, vname2, vname3 := v1, v2, v3

:= can only be used inside functions, for defining global variables we have to stick to using var. It throws a syntax error otherwise.

Blank variable

_ is called the blank variable and it is used to ignore a value.

Suppose we have a function divide, which takes two arguments, and will return the quotient and remainder of arg1 divided by arg2. But we only want the remainder, so we ignore the quotient using

1 	_ , remainder := divide(10, 3)

Unused variables cause compilation errors. Compile the following code and see what happens. Sometimes, we use this notations to import libraries which we do not want to use as prefix, while working with databases we do not want to prefix the library name to each function call of the library, so we use the blank variable. We will see that in a future chapter.

1 package main
2 
3 func main() {
4 	var i int
5 }

Constants

Constants are the values that are determined during compile time that cannot be changed during runtime. In Go, you can use number, boolean or string as types of constants.

Defining constants

1 const constantName = value
2 // you can assign type of constants if it's necessary 
3 const Pi float32 = 3.1415926

More examples. golang const Pi = 3.1415926 const i = 10000 const MaxThread = 10 const prefix = "astaxie_"

Elementary types

Boolean

The keyword bool is used to define a variable of the boolean type. There are two boolean values, true or false; false will be the default value. Unlike other languages, Go doesn’t allow us to convert boolean into number.

1 // sample code
2 var isActive bool  // global variable
3 var enabled, disabled = true, false  // omit type of variables
4 func test() {
5 	var available bool  // local variable
6 	valid := false      // brief statement of variable
7 	available = true    // assign value to variable
8 }

Numerical types

Integers

Integer types include signed and unsigned integer types, int and uint respectively. They have the same length, but the specific length depends on your operating system. They use 32-bit in 32-bit operating systems, and 64-bit in 64-bit operating systems. Go also has types that have specific length including rune, int8, int16, int32, int64, byte, uint8, uint16, uint32, uint64. Note that rune is alias of int32 and byte is alias of uint8.

Go doesn’t allow assigning values between data types. The following operation will cause compilation errors.

1 var a int8
2 
3 var b int32
4 
5 c := a + b

Although int32 has a longer length than int8, and has the same type as int, you cannot assign values between them. ( c will be asserted as type int here )

Fractions

Float types have the float32 and float64 types and no type called float. The latter one is the default type if using brief statement.

Complex numbers

Go supports complex numbers as well. complex128 (with a 64-bit real and 64-bit imaginary part) is the default type, if you need a smaller type, there is one called complex64 (with a 32-bit real and 32-bit imaginary part). Its form is RE+IMi, where RE is real part and IM is imaginary part, the last i is the imaginary number. There is a example of complex number.

1 	var c complex64 = 5+5i
2 	//output: (5+5i)
3 	fmt.Printf("Value is: %v", c)

String

Go uses the UTF-8 character set. Strings are represented by double quotes "" or backticks ``.

1 // sample code
2 var frenchHello string  // basic form to define string
3 var emptyString string = ""  // define a string with empty string
4 func test() {
5 	no, yes, maybe := "no", "yes", "maybe"  // brief statement
6 	japaneseHello := "Ohaiou"
7 	frenchHello = "Bonjour"  // basic form of assign values
8 }

String objects do not now allow value change. You will get errors when you compile the following code.

1 var s string = "hello"
2 s[0] = 'c'

For changing a string, a new string has to be created using the old string. Go doesn’t allow modifications to a string variable, but you can always create a new one.

1 s := "hello"
2 c := []byte(s)  // convert string to []byte type
3 c[0] = 'c'
4 s2 := string(c)  // convert back to string type
5 fmt.Printf("%s\n", s2)

+ operator can be used to concatenate two strings.

1 s := "hello,"
2 m := " world"
3 a := s + m
4 fmt.Printf("%s\n", a)

and also.

1 s := "hello"
2 s = "c" + s[1:] // returns substring from index 1 till the end.
3 fmt.Printf("%s\n", s)

` (backtick) is used to have a multiple-line string.

1 m := `hello
2 world`

\ ` (backtick) will not escape any characters in a string.

Error types

Go doesn’t have the try catch block. There is one error type for the purpose of dealing with errors in the package called errors. Go requires us to explicitly handle our errors or ignore them. Typical error handling forms a if err != nil ladder.

1 err := errors.New("emit macho dwarf: elf header corrupted")
2 if err != nil {
3 	fmt.Print(err)
4 }

Underlying data structures

The following picture comes from an article about Go data structure in Russ Cox’s Blog. As you can see, Go utilizes blocks of memory to store data.

Important points

Define by group

If you want to define multiple constants, variables or import packages, you can use the group form.

Basic form.

 1 import "fmt"
 2 import "os"
 3 
 4 const i = 100
 5 const pi = 3.1415
 6 const prefix = "Go_"
 7 
 8 var i int
 9 var pi float32
10 var prefix string

Group form.

 1 // if you have imports from both standard library and custom 
 2 // imports, the standard library imports go first, 
 3 // followed by others.
 4 
 5 import(
 6 	"fmt"
 7 	"os"
 8 
 9 	"github.com/thewhitetulip/Tasks/views"
10 )
11 
12 // value of first const will be 0 unless it is assigned to iota
13 // If there are no assigned values for the elements except the last one, 
14 // all constants will have the same value as the last one.
15 
16 const(
17 	i = 100
18 	pi = 3.1415
19 	prefix = "Go_"
20 )
21 
22 var(
23 	i int
24 	pi float32
25 	prefix string
26 )

iota enumerate

Go has a keyword called iota, this keyword is to make enum, it begins with 0, increased by 1.

 1 const(
 2 	x = iota  // x == 0
 3 	y = iota  // y == 1
 4 	z = iota  // z == 2
 5 	w  // If there is no expression after the constants name, 
 6 		// it uses the last expression, 
 7 	// so it's saying w = iota implicitly. Therefore w == 3, 
 8 	// and y and z both can omit "= iota" as well.
 9 )
10 
11 const v = iota // once iota meets keyword `const`, it resets to `0`, so v = 0.
12 
13 const ( 
14 	e, f, g = iota, iota, iota // e=0,f=0,g=0 values of iota are same in one line.
15 )

Some rules

Go is concise because it has some default behaviors.

• Any variable that begins with a capital letter means it will be exported, private otherwise.
• The same rule applies for functions and constants, no public or private keyword exist in Go.

array, slice, map

array

arr is an array, we define one as follows.

1 var arr [n]type

in [n]type, n is the length of the array, type is the type of its elements. Like other languages, we use [] to get or set element values within arrays.

1 var arr [10]int  // an array of type [10]int
2 arr[0] = 42      // array is 0-based
3 arr[1] = 13      // assign value to element
4 fmt.Printf("The first element is %d\n", arr[0])  
5 // get element value, it returns 42
6 fmt.Printf("The last element is %d\n", arr[9]) 
7 // it returns default value of 10th element in this array,
8 // which is 0 in this case.

Since length is a part of the array type, [3]int and [4]int are different types. We cannot change the length of arrays.

Arrays are passed as copy rather than references when passed to a function as arguments. For references, we have to use slice. More about slices below.

It’s possible to use := when you define arrays.

1 a := [3]int{1, 2, 3} // define an int array with 3 elements
2 
3 b := [10]int{1, 2, 3} 
4 // define a int array with 10 elements, of which the first three are assigned. 
5 //The rest of them use the default value 0.
6 
7 c := [...]int{4, 5, 6} // use `…` to replace the length parameter and Go will calcul\
8 ate it for you.

You may want to use arrays as arrays’ elements. Let’s see how to do this.

1 // define a two-dimensional array with 2 elements, and each element has 4 elements.
2 doubleArray := [2][4]int{[4]int{1, 2, 3, 4}, [4]int{5, 6, 7, 8}}
3 
4 // The declaration can be written more concisely as follows.
5 easyArray := [2][4]int{{1, 2, 3, 4}, {5, 6, 7, 8}}

Array underlying data structure.

slice

The main disadvantage of arrays is that we need to know the size prehand. At times this isn’t possible. For this, we need a “dynamic array”. This is called a slice in Go.

slice is not really a dynamic array. It’s a reference type. slice points to an underlying array whose declaration is similar to array, but doesn’t need length.

1 // just like defining an array, but this time, we exclude the length.
2 var fslice []int

Then we define a slice, and initialize its data.

1 slice := []byte {'a', 'b', 'c', 'd'}

slice can redefine existing slices or arrays. slice uses array[i:j] to slice, where i is the start index and j is end index, but notice that array[j] will not be sliced since the length of the slice is j - i.

 1 // define an array with 10 elements whose types are bytes
 2 var ar = [10]byte {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'}
 3 
 4 // define two slices with type []byte
 5 var a, b []byte
 6 
 7 // 'a' points to elements from 3rd to 5th in array ar.
 8 a = ar[2:5]
 9 // now 'a' has elements ar[2],ar[3] and ar[4]
10 
11 // 'b' is another slice of array ar
12 b = ar[3:5]
13 // now 'b' has elements ar[3] and ar[4]

Notice the differences between slice and array when you define them. We use […] to let Go calculate length but use [] to define slice only. Slices do not have length, slices point to arrays which have lengths.

Their underlying data structure.

slice has some convenient operations.

• slice is 0-based, ar[:n] equals to ar[0:n]
• The second index will be the length of slice if omitted, ar[n:] equals to ar[n:len(ar)].
• You can use ar[:] to slice whole array, reasons are explained in first two statements.

More examples:

 1 // define an array
 2 var array = [10]byte{'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'}
 3 // define two slices
 4 var aSlice, bSlice []byte
 5 
 6 // some convenient operations
 7 aSlice = array[:3] // equals to aSlice = array[0:3] aSlice has elements a,b,c
 8 aSlice = array[5:] // equals to aSlice = array[5:10] aSlice has elements f,g,h,i,j
 9 aSlice = array[:]  // equals to aSlice = array[0:10] aSlice has all elements
10 
11 // slice from slice
12 aSlice = array[3:7]  // aSlice has elements d,e,f,g，len=4，cap=7
13 bSlice = aSlice[1:3] // bSlice contains aSlice[1], aSlice[2], so it has elements e,f
14 bSlice = aSlice[:3]  // bSlice contains aSlice[0], aSlice[1], aSlice[2], so it has d\
15 ,e,f
16 bSlice = aSlice[0:5] // slice could be expanded in range of cap, now bSlice contains\
17  d,e,f,g,h
18 bSlice = aSlice[:]   // bSlice has same elements as aSlice does, which are d,e,f,g

slice is a reference type, so any changes will affect other variables pointing to the same slice or array. For instance, in the case of aSlice and bSlice above, if you change the value of an element in aSlice, bSlice will be changed as well.

slice is like a struct by definition and it contains 3 parts.

• A pointer that points to where slice starts.
• The length of slice.
• Capacity, the length from start index to end index of slice.

1 Array_a := [10]byte{'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'}
2 Slice_a := Array_a[2:5]

The underlying data structure of the code above as follows.

There are some built-in functions for slice.

• len gets the length of slice.
• cap gets the maximum length of slice
• append appends one or more elements to slice, and returns slice .
• copy copies elements from one slice to the other, and returns the number of elements that were copied.

Attention: append will change the array that slice points to, and affect other slices that point to the same array.

Also, if there is not enough length for the slice ((cap-len) == 0), append returns a new array for this slice. When this happens, other slices pointing to the old array will not be affected.

map

Map is a key value pair, like a dictionary in Python. Use the form map[keyType]valueType to define it.

The ‘set’ and ‘get’ values in map are similar to slice, however the index in slice can only be of type ‘int’ while map can use much more than that: for example int, string, or whatever you want. Also, they are all able to use == and != to compare values.

 1 // use string as the key type, int as the value type, and `make` initialize it.
 2 var numbers map[string] int
 3 // another way to define map
 4 numbers := make(map[string]int)
 5 numbers["one"] = 1  // assign value by key
 6 numbers["ten"] = 10 
 7 numbers["three"] = 3
 8 
 9 fmt.Println("The third number is: ", numbers["three"]) // get values
10 // It prints: The third number is: 3

Some notes when you use map.

• map is disorderly. Everytime you print map you will get different results. It’s impossible to get values by index. You have to use key.
• map doesn’t have a fixed length. It’s a reference type just like slice.
• len works for map also. It returns how many keys that map has.
• It’s quite easy to change the value through map. Simply use numbers["one"]=11 to change the value of key one to 11.

You can use form key:val to initialize map’s values, and map has built-in methods to check if the key exists.

Use delete to delete an element in map.

 1 // Initialize a map
 2 rating := map[string]float32 {"C":5, "Go":4.5, "Python":4.5, "C++":2 }
 3 // map has two return values. For the second return value, if the key doesn't 
 4 //exist，'ok' returns false. It returns true otherwise.
 5 csharpRating, ok := rating["C#"]
 6 if ok {
 7 		fmt.Println("C# is in the map and its rating is ", csharpRating)
 8 } else {
 9 		fmt.Println("We have no rating associated with C# in the map")
10 }
11 
12 delete(rating, "C")  // delete element with key "c"

As I said above, map is a reference type. If two maps point to same underlying data, any change will affect both of them.

1 m := make(map[string]string)
2 m["Hello"] = "Bonjour"
3 m1 := m
4 m1["Hello"] = "Salut"  // now the value of m["Hello"] is Salut

make, new

make does memory allocation for built-in models, such as map, slice, and channel, while new is for types’ memory allocation.

new(T) allocates zero-value to type T’s memory, returns its memory address, which is the value of type *T. By Go’s definition, it returns a pointer which points to type T’s zero-value.

new returns pointers.

The built-in function make(T, args) has different purposes than new(T). make can be used for slice, map, and channel, and returns a type T with an initial value. The reason for doing this is because the underlying data of these three types must be initialized before they point to them. For example, a slice contains a pointer that points to the underlying array, length and capacity. Before these data are initialized, slice is nil, so for slice, map and channel, make initializes their underlying data and assigns some suitable values.

make returns non-zero values.

The following picture shows how new and make are different.

Zero-value does not mean empty value. It’s the value that variables default to in most cases. Here is a list of some zero-values.

 1 int     0
 2 int8    0
 3 int32   0
 4 int64   0
 5 uint    0x0
 6 rune    0 // the actual type of rune is int32
 7 byte    0x0 // the actual type of byte is uint8
 8 float32 0 // length is 4 byte
 9 float64 0 //length is 8 byte
10 bool    false
11 string  ""

Links

-Previous section -Next section

Control statements and Functions

Control statement

if

if doesn’t need parentheses in Go. golang if x > 10 { //when x is greater than 10 //program enters this block fmt.Println("x is greater than 10") } else { //when x is smaller than 10 //program enters this block fmt.Println("x is less than or equal to 10") }

Go allows us to initialize and use variables in if like this: ```golang // initialize x, then check if x greater than if x := computedValue(); x > 10 { fmt.Println(“x is greater than 10”) } else { fmt.Println(“x is less than 10”) }

// the following code will not compile fmt.Println(x) ```

For multiple conditions we use the else if block golang if integer == 3 { fmt.Println("The integer is equal to 3") } else if integer < 3 { fmt.Println("The integer is less than 3") } else { fmt.Println("The integer is greater than 3") }

goto

Go has a goto keyword, but be careful when you use it. goto reroutes the control flow to a previously defined label within the body of same code block.

1 func myFunc() {
2 	i := 0
3 Here:   // label ends with ":"
4 	fmt.Println(i)
5 	i++
6 	goto Here   // jump to label "Here"
7 }

The label name is case sensitive.

for

Go does not have while, do while. Just a for, which is the most powerful control logic. It can read data in loops and iterative operations, just like while. Like if, for doesn’t need parenthesis.

1 for expression1; expression2; expression3 {
2 	//...
3 }

 1 package main
 2 import "fmt"
 3 
 4 func main(){
 5 	sum := 0;
 6 	for index:=0; index < 10 ; index++ {
 7 		sum += index
 8 	}
 9 	fmt.Println("sum is equal to ", sum)
10 }
11 // Print: sum is equal to 45

We can omit one or more expressions.

1 sum := 1
2 for ; sum < 1000;  {
3 	sum += sum
4 }
5 
6 for {
7 	//this is an infinite loop
8 }

Using for like a while

1 sum := 1
2 for sum < 1000 {
3 	sum += sum
4 }

break and continue

break: jumps out of the loop. If you have nested loops, use break along with labels.

continue skips the current loop and starts the next one

1 for index := 10; index>0; index-- {
2 	if index == 5{
3 		break // or continue
4 	}
5 	fmt.Println(index)
6 }
7 // break prints 10、9、8、7、6
8 // continue prints 10、9、8、7、6、4、3、2、1

for can read data from slice and map when it is used together with range.

1 for k,v:=range map {
2 	fmt.Println("map's key:",k)
3 	fmt.Println("map's val:",v)
4 }

Because Go supports multi-value returns and gives compile errors when you don’t use values that were defined, as discussed earlier, _ is used to discard certain return values.

1 for _, v := range map{
2 	fmt.Println("map's val:", v)
3 }

switch

Switch is an easier way to avoid long if-else statements.

 1 switch sExpr {
 2 case expr1:
 3 	some instructions
 4 case expr2:
 5 	some other instructions
 6 case expr3:
 7 	some other instructions
 8 default:
 9 	other code
10 }

The type of sExpr, expr1, expr2, and expr3 must be the same.

Conditions don’t have to be constants and it checks the cases from top to bottom until it matches conditions and executes only the matching case.

If there is no statement after the keyword switch, then it matches true.

The default case is when there is no match to the switch.

 1 i := 10
 2 switch i {
 3 case 1:
 4 	fmt.Println("i is equal to 1")
 5 case 2, 3, 4:
 6 	fmt.Println("i is equal to 2, 3 or 4")
 7 case 10:
 8 	fmt.Println("i is equal to 10")
 9 default:
10 	fmt.Println("All I know is that i is an integer")
11 }

Cases can have more than one values separated by a comma. By default switch executes only the matching case, however we can make switch execute the matching case and all cases below it using the fallthrough statement.

 1 integer := 6
 2 switch integer {
 3 case 4:
 4 	fmt.Println("integer <= 4")
 5 	fallthrough
 6 case 5:
 7 	fmt.Println("integer <= 5")
 8 	fallthrough
 9 case 6:
10 	fmt.Println("integer <= 6")
11 	fallthrough
12 case 7:
13 	fmt.Println("integer <= 7")
14 	fallthrough
15 case 8:
16 	fmt.Println("integer <= 8")
17 	fallthrough
18 default:
19 	fmt.Println("default case")
20 }

This program prints the following information.

integer <= 6 integer <= 7 integer <= 8 default case

Functions

func keyword is used to define a function.

1 func funcName(input1 type1, input2 type2) (output1 type1, output2 type2) {
2 	// function body
3 	// multi-value return
4 	return value1, value2
5 }

• Functions may have zero, one or more than one arguments. The argument type comes after the argument name and arguments are separated by ,.
• Functions can return multiple values.
• There are two return values named output1 and output2, you can omit their names and use their type only.
• If there is only one return value and you omitted the name, you don’t need brackets for the return values.
• If the function doesn’t have return values, you can omit the return parameters altogether.
• If the function has return values, you have to use the return statement somewhere in the body of the function.

A simple program to calculate maximum value.

 1 package main
 2 import "fmt"
 3 
 4 // returns the greater value between a and b
 5 func max(a, b int) int {
 6 	if a > b {
 7 		return a
 8 	}
 9 	return b
10 }
11 
12 func main() {
13 	x := 3
14 	y := 4
15 	z := 5
16 
17 	max_xy := max(x, y) // call function max(x, y)
18 	max_xz := max(x, z) // call function max(x, z)
19 
20 	fmt.Printf("max(%d, %d) = %d\n", x, y, max_xy)
21 	fmt.Printf("max(%d, %d) = %d\n", x, z, max_xz)
22 	fmt.Printf("max(%d, %d) = %d\n", y, z, max(y,z)) // call function here
23 }

In a function call, if two or more arguments have the same data type, then we can put the data type only after the last argument.

func max(a,b int, c,d string): this means we have four arguments, a,b: integers and c,d: string.

Multi-value return

 1 package main
 2 import "fmt"
 3 
 4 // return results of A + B and A * B
 5 func SumAndProduct(A, B int) (int, int) {
 6 	return A+B, A*B
 7 }
 8 
 9 func main() {
10 	x := 3
11 	y := 4
12 
13 	xPLUSy, xTIMESy := SumAndProduct(x, y)
14 
15 	fmt.Printf("%d + %d = %d\n", x, y, xPLUSy)
16 	fmt.Printf("%d * %d = %d\n", x, y, xTIMESy)
17 }

SumAndProduct will return two values without names. Go allows us to have named return arguments. By using named arguments, the respective variables are returned automatically, we would just need to use return.

If functions are going to be used outside of current program, it is better to explicitly write return statements for the sake of readability.

1 func SumAndProduct(A, B int) (add int, multiplied int) {
2 	add = A+B
3 	multiplied = A*B
4 	return
5 }
6 // Since return arguments are named, the function automatically
7 // returns them

Variadic arguments to functions

In many cases, we do not know how many arguements can be passed, in such cases, we use variadic arguments.

func myfunc(arg …int) {}

arg …int tells Go that this is a function that has variable arguments. Notice that these arguments are type int. In the body of function, the arg becomes a slice of int.

for _, n := range arg { fmt.Printf(“And the number is: %d\n”, n) }

Pass by value and pointers

Argument are passed by value to the functions, the argument change inside the function doesn’t affect the arguments used to call the function.

 1 package main
 2 import "fmt"
 3 
 4 // simple function to add 1 to a
 5 func add1(a int) int {
 6 	a = a+1 // we change value of a
 7 	return a // return new value of a
 8 }
 9 
10 func main() {
11 	x := 3
12 
13 	fmt.Println("x = ", x)  // should print "x = 3"
14 
15 	x1 := add1(x)  // call add1(x)
16 
17 	fmt.Println("x+1 = ", x1) // should print "x+1 = 4"
18 	fmt.Println("x = ", x)    // should print "x = 3"
19 }

The original value of x doesn’t change, because we passed x as a value, so the function add1 created a copy of x. Despite having the same names, the both variables are totally independant of each other.

In cases where we want to be able to modify the argument’s value, we use pass by reference using pointers.

In reality, a variable is nothing but a pointer to a location in memory. Each variable has a unique memory address. So, if we want to change the value of a variable, we must change its memory address. Therefore the function add1 has to know the memory address of x in order to change its value. Here we pass &x to the function, and change the argument’s type to the pointer type *int. Be aware that we pass a copy of the pointer, not copy of value.

 1 package main
 2 import "fmt"
 3 
 4 // simple function to add 1 to a
 5 func add1(a *int) int {
 6 	*a = *a+1 // we changed value of a
 7 	return *a // return new value of a
 8 }
 9 
10 func main() {
11 	x := 3
12 
13 	fmt.Println("x = ", x)  // should print "x = 3"
14 
15 	x1 := add1(&x)  // call add1(&x) pass memory address of x
16 
17 	fmt.Println("x+1 = ", x1) // should print "x+1 = 4"
18 	fmt.Println("x = ", x)    // should print "x = 4"
19 }

Advantages of pointers:

• Allows us to use more functions to operate on one variable.
• Low cost by passing memory addresses (8 bytes), copy is not an efficient way, both in terms of time and space, to pass variables.
• string, slice and map are reference types, so they use pointers when passing to functions by default. (Attention: If you need to change the length of slice, you have to pass pointers explicitly)

defer

Defer postpones the execution of a function till the calling function has finished executing. You can have many defer statements in one function; they will execute in reverse order when the program reaches its end. In the case where the program opens some resource files, these files would have to be closed before the function can return with errors. Let’s see some examples.

 1 func ReadWrite() bool {
 2 	file.Open("file")
 3 	// Do some work
 4 	if failureX {
 5 		file.Close()
 6 		return false
 7 	}
 8 
 9 	if failureY {
10 		file.Close()
11 		return false
12 	}
13 
14 	file.Close()
15 	return true
16 }

We saw some code being repeated several times. defer solves this problem very well. It doesn’t only help you to write clean code but also makes your code more readable.

 1 func ReadWrite() bool {
 2 	file.Open("file")
 3 	defer file.Close()
 4 	if failureX {
 5 		return false
 6 	}
 7 	if failureY {
 8 		return false
 9 	}
10 	return true
11 }

If there are more than one defers, they will execute by reverse order. The following example will print 4 3 2 1 0.

1 for i := 0; i < 5; i++ {
2 	defer fmt.Printf("%d ", i)
3 }

Functions as values and types

Functions are also variables in Go, we can use type to define them. Functions that have the same signature can be seen as the same type.

type typeName func(input1 inputType1 , input2 inputType2 [, …]) (result1 resultType1 [, …])

This makes Go a functional language as functions are a first class citizen.

 1 package main
 2 import "fmt"
 3 
 4 type testInt func(int) bool // define a function type of variable
 5 
 6 func isOdd(integer int) bool {
 7 	if integer%2 == 0 {
 8 		return false
 9 	}
10 	return true
11 }
12 
13 func isEven(integer int) bool {
14 	if integer%2 == 0 {
15 		return true
16 	}
17 	return false
18 }
19 
20 // pass the function `f` as an argument to another function
21 
22 func filter(slice []int, f testInt) []int {
23 	var result []int
24 	for _, value := range slice {
25 		if f(value) {
26 			result = append(result, value)
27 		}
28 	}
29 	return result
30 }
31 
32 func main(){
33 	slice := []int {1, 2, 3, 4, 5, 7}
34 	fmt.Println("slice = ", slice)
35 	odd := filter(slice, isOdd)    // use function as values
36 	fmt.Println("Odd elements of slice are: ", odd)
37 	even := filter(slice, isEven)
38 	fmt.Println("Even elements of slice are: ", even)
39 }

It’s very useful when we use interfaces. As you can see testInt is a variable that has a function as type and the returned values and arguments of filter are the same as those of testInt. Therefore, we can have complex logic in our programs, while maintaining flexibility in our code.

Panic and Recover

Go doesn’t have try-catch structure like Java does. Instead of throwing exceptions, Go uses panic and recover to deal with errors. However, you shouldn’t use panic very much, although it’s powerful.

Panic is a built-in function to break the normal flow of programs and get into panic status. When a function F calls panic, F will not continue executing but its defer functions will continue to execute. Then F goes back to the break point which caused the panic status. The program will not terminate until all of these functions return with panic to the first level of that goroutine. panic can be produced by calling panic in the program, and some errors also cause panic like array access out of bounds errors.

Recover is a built-in function to recover goroutines from panic status. Calling recover in defer functions is useful because normal functions will not be executed when the program is in the panic status. It catches panic values if the program is in the panic status, and it gets nil if the program is not in panic status.

The following example shows how to use panic.

1 var user = os.Getenv("USER")
2 
3 func init() {
4 	if user == "" {
5 		panic("no value for $USER")
6 	}
7 }

The following example shows how to check panic.

1 func throwsPanic(f func()) (b bool) {
2 	defer func() {
3 		if x := recover(); x != nil {
4 			b = true
5 		}
6 	}()
7 	f() // if f causes panic, it will recover
8 	return
9 }

main and init functions

Go has two retentions which are called main and init, where init can be used in all packages and main can only be used in the main package. These two functions are not able to have arguments or return values. Even though we can write many init functions in one package, I strongly recommend writing only one init function for each package.

Go programs will call init() and main() automatically, so you don’t need to call them by yourself. For every package, the init function is optional, but package main has one and only one main function.

Programs initialize and begin execution from the main package. If the main package imports other packages, they will be imported in the compile time. If one package is imported many times, it will be only compiled once. After importing packages, programs will initialize the constants and variables within the imported packages, then execute the init function if it exists, and so on. After all the other packages are initialized, programs will initialize constants and variables in the main package, then execute the init function inside the package if it exists. The following figure shows the process.

import

import is very often used in Go programs.

1 import(
2 	"fmt"
3 )

Methods of fmt are called as follows.

1 fmt.Println("hello world")

fmt is from Go standard library, it is located within $GOROOT/pkg. Go supports third-party packages in two ways.

1. Relative path import “./model” // load package in the same directory, I don’t recommend this way.
2. Absolute path import “shorturl/model” // load package in path “$GOPATH/pkg/shorturl/model”

There are some special operators when we import packages, and beginners are always confused by these operators.

Dot operator

Sometimes we see people use following way to import packages.

1 import(
2 	. "fmt"
3 )

The dot operator means you can omit the package name when you call functions inside of that package. Now fmt.Printf("Hello world") becomes to Printf("Hello world").

Alias operation

It changes the name of the package that we imported when we call functions that belong to that package.

1 import(
2 	f "fmt"
3 )

Now fmt.Printf("Hello world") becomes to f.Printf("Hello world").

_ operator

This is the operator that is difficult to understand without someone explaining it to you.

1 import (
2 	"database/sql"
3 	_ "github.com/ziutek/mymysql/godrv"
4 )

The _ operator actually means we just want to import that package and execute its init function, and we are not sure if want to use the functions belonging to that package.

Links

-Previous section -Next section

Struct

Basics of Struct

Struct can be used to define custom data types in Go. Often times, we can not handle the real world information using the standard data types which come with languages. While it is not impossible, it is highly inefficient. For example, in an eCommerce application, we have the ShoppingCart in which we put products for checkout.

1 type Product struct {
2 	name          string
3 	itemID        int
4 	cost          float32
5 	isAvailable   bool
6 	inventoryLeft int
7 }

There are a lot of attributes of Product, its name, the ID used internally, the cost, number of the products in stock, etc.

• name is a string used to store a product’s name.
• itemID is an int used to store for reference.
• cost is a float32 of the item.
• isAvailable is a bool which is true if the item is in stock, false otherwise.
• inventoryLeft is an int of the number of products left in stock.

Initializing

1 // define goBook as a Product type
2 var goBook Product
3 // assign "Webapps in Go" to the field 'name' of goBook
4 goBook.name = "Webapps in Go"
5 // assign 10025 to field 'itemID' of goBook
6 goBook.itemID = 10025
7 // access field 'name' of goBook
8 fmt.Printf("The product's name is %s\n", goBook.name)

There are three more ways to define a struct.

• Assign initial values by order

goBook := Product{"Webapps in Go", 10025}

• Use the format field:value to initialize the struct without order

goBook := Product{name:"Webapps in Go", itemID:10025, cost:100}

• Define an anonymous struct, then initialize it

p := struct{name string; age int}{"Amy",18}

Let’s see a complete example.

file: code/Struct/Book/struct.go

 1 package main
 2 
 3 import "fmt"
 4 
 5 // Product will denote a physical object
 6 // which we will sell online to be rich
 7 type Product struct {
 8 	name          string
 9 	itemID        int
10 	cost          float32
11 	isAvailable   bool
12 	inventoryLeft int
13 }
14 
15 func main() {
16 	var goBook Product
17 
18 	// initialization
19 	goBook.name, goBook.itemID, goBook.isAvailable, goBook.inventoryLeft = "Webapps in \
20 Go", 10025, true, 25
21 
22 	// initialize four values by format "field:value"
23 	pythonBook := Product{itemID: 10026, name: "Learn Python", inventoryLeft: 0, isAvai\
24 lable: false}
25 
26 	// initialize all five values in order
27 	rubyBook := Product{"Learn Ruby", 10043, 100, true, 12}
28 
29 	if goBook.isAvailable {
30 		fmt.Printf("%d copies of %s are available\n", 
31 		goBook.inventoryLeft, goBook.name)
32 	}
33 
34 	if pythonBook.isAvailable {
35 		fmt.Printf("%d copies of %s are available\n", 
36 		pythonBook.inventoryLeft, pythonBook.name)
37 	}
38 
39 	if rubyBook.isAvailable {
40 		fmt.Printf("%d copies of %s are available\n", 
41 		rubyBook.inventoryLeft, rubyBook.name)
42 	}
43 
44 }

embedded fields in struct

In the earlier chapter, we saw how to define a struct with field names and type. Embedded fields can be thought of as subclass and superclass in Object oriented programming.

When the embedded field is a struct, all the fields in that struct will implicitly be the fields in the struct in which it has been embedded.

Let’s see one example.

file: code/Struct/Human/human.go

 1 package main
 2 import "fmt"
 3 
 4 type Human struct {
 5 	name string
 6 	age int
 7 	weight int
 8 }
 9 
10 type Student struct {
11 	Human  // embedded field, it means Student struct
12 	// includes all fields that Human has.
13 	specialty string
14 }
15 
16 func main() {
17 	// initialize a student
18 	mark := Student{Human{"Mark", 25, 120}, "Computer Science"}
19 
20 	// access fields
21 	fmt.Println("His name is ", mark.name)
22 	fmt.Println("His age is ", mark.age)
23 	fmt.Println("His weight is ", mark.weight)
24 	fmt.Println("His specialty is ", mark.specialty)
25 	// modify notes
26 	mark.specialty = "AI"
27 	fmt.Println("Mark changed his specialty")
28 	fmt.Println("His specialty is ", mark.specialty)
29 	// modify age
30 	fmt.Println("Mark become old")
31 	mark.age = 46
32 	fmt.Println("His age is", mark.age)
33 	// modify weight
34 	fmt.Println("Mark is not an athlete anymore")
35 	mark.weight += 60
36 	fmt.Println("His weight is", mark.weight)
37 }

We see that we can access the age and name fields in Student just like we can in Human. This is how embedded fields work. We can even use Student to access Human in this embedded field!

1 mark.Human = Human{"Marcus", 55, 220}
2 mark.Human.age -= 1

All the types in Go can be used as embedded fields.

file: code/Struct/Skills/skills.go

 1 package main
 2 
 3 import "fmt"
 4 
 5 type Skills []string
 6 
 7 type Human struct {
 8 	name   string
 9 	age    int
10 	weight int
11 }
12 
13 type Student struct {
14 	Human     // struct as embedded field
15 	Skills    // string slice as embedded field
16 	int       // built-in type as embedded field
17 	specialty string
18 }
19 
20 func main() {
21 	// initialize Student Jane
22 	jane := Student{Human: Human{"Jane", 35, 100}, specialty: "Biology"}
23 	// access fields
24 	fmt.Println("Her name is ", jane.name)
25 	fmt.Println("Her age is ", jane.age)
26 	fmt.Println("Her weight is ", jane.weight)
27 	fmt.Println("Her specialty is ", jane.specialty)
28 	// modify value of skill field
29 	jane.Skills = []string{"anatomy"}
30 	fmt.Println("Her skills are ", jane.Skills)
31 	fmt.Println("She acquired two new ones ")
32 	jane.Skills = append(jane.Skills, "physics", "golang")
33 	fmt.Println("Her skills now are ", jane.Skills)
34 	// modify embedded field
35 	jane.int = 3
36 	fmt.Println("Her preferred number is ", jane.int)
37 }

In the above example, we can see that all types can be embedded fields and we can use functions to operate on them.

When we embed Human inside Employee, if Human and Employee have the phone field, then it isn’t a problem. Because we access Employee’s phone as Employee.Phone, but since Human is an embedded field inside Employee, we access Human’s phone as Employee.Human.Phone

file: code/Struct/Employee/employee.go

 1 package main
 2 
 3 import "fmt"
 4 
 5 type Human struct {
 6 	name  string
 7 	age   int
 8 	phone string // Human has phone field
 9 }
10 
11 type Employee struct {
12 	Human     // embedded field Human
13 	specialty string
14 	phone     string // phone in employee
15 }
16 
17 func main() {
18 	Bob := Employee{Human{"Bob", 34, "777-444-XXXX"},
19 		"Designer", "333-222"}
20 	fmt.Println("Bob's work phone is:", Bob.phone)
21 	// access phone field in Human
22 	fmt.Println("Bob's personal phone is:", Bob.Human.phone)
23 }

Links

-Previous section -Next section

Object-oriented

Object oriented languages allow programmers to declare a function inside the class definition. Go doesn’t allow us to do that, we have to declare a method on a struct via a special syntax.

methods

We defined a “rectangle” struct and we want to calculate its area. Normally, we would create a function, pass the struct’s instance and calculate the area.

 1 package main
 2 import "fmt"
 3 
 4 type Rectangle struct {
 5 	width, height float64
 6 }
 7 
 8 func area(r Rectangle) float64 {
 9 	return r.width*r.height
10 }
11 
12 func main() {
13 	r1 := Rectangle{12, 2}
14 	r2 := Rectangle{9, 4}
15 	fmt.Println("Area of r1 is: ", area(r1))
16 	fmt.Println("Area of r2 is: ", area(r2))
17 }

The above example calculates a rectangle’s area. The function and struct are two independent things as you may notice.

The problem arises when we want to generalize things, suppose we want to calculate area of a square, we need to define yet another function called area, but we can’t have two functions of the same name in a file. Also area isn’t a property of the struct Rectangle.

A method is affiliated with the type. It has the same syntax as functions do except for an additional parameter after the func keyword called the receiver, which is the main body of that method.

Using the same example, Rectangle.area() belongs directly to rectangle, instead of as a peripheral function. More specifically, length, width and area() all belong to rectangle.

As Rob Pike said.

“A method is a function with an implicit first argument, called a receiver.”

Syntax of method.

1 func (r ReceiverType) funcName(parameters) (results)

Let’s change our example using method instead.

file: code/ObjectOriented/area/area.go

 1 package main
 2 import (
 3 	"fmt"
 4 	"math"
 5 )
 6 
 7 type Rectangle struct {
 8 	width, height float64
 9 }
10 
11 type Circle struct {
12 	radius float64
13 }
14 
15 func (r Rectangle) area() float64 {
16 	return r.width*r.height
17 }
18 
19 func (c Circle) area() float64 {
20 	return c.radius * c.radius * math.Pi
21 }
22 
23 func main() {
24 	r1 := Rectangle{12, 2}
25 	r2 := Rectangle{9, 4}
26 	c1 := Circle{10}
27 	c2 := Circle{25}
28 
29 	fmt.Println("Area of r1 is: ", r1.area())
30 	fmt.Println("Area of r2 is: ", r2.area())
31 	fmt.Println("Area of c1 is: ", c1.area())
32 	fmt.Println("Area of c2 is: ", c2.area())
33 }

Notes for using methods.

• If the name of methods are the same but they don’t share the same receivers, they are not the same.
• Methods are able to access fields within receivers.
• Use . to call a method in the struct, the same way fields are called.

In the example above, the area() methods belong to both Rectangle and Circle respectively, so the receivers are Rectangle and Circle.

One thing that’s worth noting is that the method with a dotted line means the receiver is passed by value, not by reference. The difference between them is that a method can change its receiver’s values when the receiver is passed by reference, and it gets a copy of the receiver when the receiver is passed by value.

Any type can be the receiver of a method.

Custom data types

Use the following format to define a custom type.

1 type typeName typeLiteral

Examples of customized types:

 1 type ages int
 2 
 3 type money float32
 4 
 5 type months map[string]int
 6 
 7 m := months {
 8 	"January":31,
 9 	"February":28,
10 	...
11 	"December":31,
12 }

Similar to typedef in C, we use ages to substitute int in the above example.

You can use as many methods in custom types as you want.

file: code/ObjectOriented/box/box.go

 1 package main
 2 import "fmt"
 3 
 4 const(
 5 	WHITE = iota
 6 	BLACK
 7 	BLUE
 8 	RED
 9 	YELLOW
10 )
11 
12 type Color byte
13 
14 type Box struct {
15 	width, height, depth float64
16 	color Color
17 }
18 
19 type BoxList []Box //a slice of boxes
20 
21 func (b Box) Volume() float64 {
22 	return b.width * b.height * b.depth
23 }
24 
25 func (b *Box) SetColor(c Color) {
26 	b.color = c
27 }
28 
29 func (bl BoxList) BiggestsColor() Color {
30 	v := 0.00
31 	k := Color(WHITE)
32 	for _, b := range bl {
33 		if b.Volume() > v {
34 			v = b.Volume()
35 			k = b.color
36 		}
37 	}
38 	return k
39 }
40 
41 func (bl BoxList) PaintItBlack() {
42 	for i, _ := range bl {
43 		bl[i].SetColor(BLACK)
44 	}
45 }
46 
47 func (c Color) String() string {
48 	strings := []string {"WHITE", "BLACK", "BLUE", "RED", "YELLOW"}
49 	return strings[c]
50 }
51 
52 func main() {
53 	boxes := BoxList {
54 		Box{4, 4, 4, RED},
55 		Box{10, 10, 1, YELLOW},
56 		Box{1, 1, 20, BLACK},
57 		Box{10, 10, 1, BLUE},
58 		Box{10, 30, 1, WHITE},
59 		Box{20, 20, 20, YELLOW},
60 	}
61 
62 	fmt.Printf("We have %d boxes in our set\n", len(boxes))
63 	fmt.Println("The volume of the first one is", boxes[0].Volume(), "cm続")
64 	fmt.Println("The color of the last one is",boxes[len(boxes)-1].color.String())
65 	fmt.Println("The biggest one is", boxes.BiggestsColor().String())
66 
67 	fmt.Println("Let's paint them all black")
68 	boxes.PaintItBlack()
69 	fmt.Println("The color of the second one is", boxes[1].color.String())
70 
71 	fmt.Println("Obviously, now, the biggest one is", boxes.BiggestsColor().String())
72 }

We define some constants and customized types.

• Use Color as alias of byte.
• Define a struct Box which has fields height, width, length and color.
• Define a struct BoxList which has Box as its field.

Then we defined some methods for our customized types.

• Volume() uses Box as its receiver and returns the volume of Box.
• SetColor(c Color) changes Box’s color.
• BiggestsColor() returns the color which has the biggest volume.
• PaintItBlack() sets color for all Box in BoxList to black.
• String() use Color as its receiver, returns the string format of color name.

Is it much clearer when we use words to describe our requirements? We often write our requirements before we start coding.

Use pointer as receiver

Let’s take a look at SetColor method. Its receiver is a pointer of Box. Yes, you can use *Box as a receiver. Why do we use a pointer here? Because we want to change Box’s color in this method. Thus, if we don’t use a pointer, it will only change the value inside a copy of Box.

If we see that a receiver is the first argument of a method, it’s not hard to understand how it works.

You might be asking why we aren’t using (*b).Color=c instead of b.Color=c in the SetColor() method. Either one is OK here because Go knows how to interpret the assignment. Do you think Go is more fascinating now?

You may also be asking whether we should use (&bl[i]).SetColor(BLACK) in PaintItBlack because we pass a pointer to SetColor. Again, either one is OK because Go knows how to interpret it!

Inheritance of method

We learned about inheritance of fields in the last section. Similarly, we also have method inheritance in Go. If an anonymous field has methods, then the struct that contains the field will have all the methods from it as well.

file: code/ObjectOriented/employee/employee.go

 1 package main
 2 import "fmt"
 3 
 4 type Human struct {
 5 	name string
 6 	age int
 7 	phone string
 8 }
 9 
10 type Student struct {
11 	Human // anonymous field
12 	school string
13 }
14 
15 type Employee struct {
16 	Human 
17 	company string
18 }
19 
20 // define a method in Human
21 func (h *Human) SayHi() {
22 	fmt.Printf("Hi, I am %s you can call me on %s\n", h.name, h.phone)
23 }
24 
25 func main() {
26 	mark := Student{Human{"Mark", 25, "222-222-YYYY"}, "MIT"}
27 	sam := Employee{Human{"Sam", 45, "111-888-XXXX"}, "Golang Inc"}
28 
29 	mark.SayHi()
30 	sam.SayHi()
31 }

Method overload

If we want Employee to have its own method SayHi, we can define a method that has the same name in Employee, and it will hide SayHi in Human when we call it.

file: code/ObjectOriented/human/human.go

 1 package main
 2 import "fmt"
 3 
 4 type Human struct {
 5 	name string
 6 	age int
 7 	phone string
 8 }
 9 
10 type Student struct {
11 	Human 
12 	school string
13 }
14 
15 type Employee struct {
16 	Human 
17 	company string
18 }
19 
20 func (h *Human) SayHi() {
21 	fmt.Printf("Hi, I am %s you can call me on %s\n", h.name, h.phone)
22 }
23 
24 func (e *Employee) SayHi() {
25 	fmt.Printf("Hi, I am %s, I work at %s. Call me on %s\n", e.name,
26 		e.company, e.phone) //Yes you can split into 2 lines here.
27 }
28 
29 func main() {
30 	mark := Student{Human{"Mark", 25, "222-222-YYYY"}, "MIT"}
31 	sam := Employee{Human{"Sam", 45, "111-888-XXXX"}, "Golang Inc"}
32 
33 	mark.SayHi()
34 	sam.SayHi()
35 }

Methods use rule of capital letter to decide whether public or private as well.

Links

-Previous section -Next section

Interface

Interface

One of the subtlest design features in Go are interfaces. After reading this section, you will likely be impressed by their implementation.

What is an interface?

In short, an interface is a set of methods that we use to define a set of actions.

Like the examples in previous sections, both Student and Employee can SayHi(), but they don’t do the same thing.

Let’s do some more work. We’ll add one more method Sing() to them, along with the BorrowMoney() method to Student and the SpendSalary() method to Employee.

Now, Student has three methods called SayHi(), Sing() and BorrowMoney(), and Employee has SayHi(), Sing() and SpendSalary().

This combination of methods is called an interface and is implemented by both Student and Employee. So, Student and Employee implement the interface: SayHi() and Sing(). At the same time, Employee doesn’t implement the interface: SayHi(), Sing(), BorrowMoney(), and Student doesn’t implement the interface: SayHi(), Sing(), SpendSalary(). This is because Employee doesn’t have the method BorrowMoney() and Student doesn’t have the method SpendSalary().

Types of Interface

An interface defines a set of methods, so if a type implements all the methods we say that it implements the interface.

 1 type Human struct {
 2 	name  string
 3 	age   int
 4 	phone string
 5 }
 6 
 7 type Student struct {
 8 	Human
 9 	school string
10 	loan   float32
11 }
12 
13 type Employee struct {
14 	Human
15 	company string
16 	money   float32
17 }
18 
19 func (h *Human) SayHi() {
20 	fmt.Printf("Hi, I am %s you can call me on %s\n", h.name, h.phone)
21 }
22 
23 func (h *Human) Sing(lyrics string) {
24 	fmt.Println("La la, la la la, la la la la la...", lyrics)
25 }
26 
27 func (h *Human) Guzzle(beerStein string) {
28 	fmt.Println("Guzzle Guzzle Guzzle...", beerStein)
29 }
30 
31 // Employee overloads Sayhi
32 func (e *Employee) SayHi() {
33 	fmt.Printf("Hi, I am %s, I work at %s. Call me on %s\n", e.name,
34 		e.company, e.phone) //Yes you can split into 2 lines here.
35 }
36 
37 func (s *Student) BorrowMoney(amount float32) {
38 	s.loan += amount // (again and again and...)
39 }
40 
41 func (e *Employee) SpendSalary(amount float32) {
42 	e.money -= amount // More vodka please!!! Get me through the day!
43 }
44 
45 // define interface
46 type Men interface {
47 	SayHi()
48 	Sing(lyrics string)
49 	Guzzle(beerStein string)
50 }
51 
52 type YoungChap interface {
53 	SayHi()
54 	Sing(song string)
55 	BorrowMoney(amount float32)
56 }
57 
58 type ElderlyGent interface {
59 	SayHi()
60 	Sing(song string)
61 	SpendSalary(amount float32)
62 }

We know that an interface can be implemented by any type, and one type can implement many interfaces simultaneously.

Note that any type implements the empty interface interface{} because it doesn’t have any methods and all types have zero methods by default.

Value of interface

So what kind of values can be put in the interface? If we define a variable as a type interface, any type that implements the interface can be assigned to this variable.

Like the above example, if we define a variable “m” as interface Men, then any one of Student, Human or Employee can be assigned to “m”. So we could have a slice of Men, and any type that implements interface Men can assign to this slice. Be aware however that the slice of interface doesn’t have the same behavior as a slice of other types.

file: code/Interface/InterfaceValue/value.go

 1 package main
 2 
 3 import "fmt"
 4 
 5 type Human struct {
 6 	name  string
 7 	age   int
 8 	phone string
 9 }
10 
11 type Student struct {
12 	Human
13 	school string
14 	loan   float32
15 }
16 
17 type Employee struct {
18 	Human
19 	company string
20 	money   float32
21 }
22 
23 func (h Human) SayHi() {
24 	fmt.Printf("Hi, I am %s you can call me on %s\n", h.name, h.phone)
25 }
26 
27 func (h Human) Sing(lyrics string) {
28 	fmt.Println("La la la la...", lyrics)
29 }
30 
31 func (e Employee) SayHi() {
32 	fmt.Printf("Hi, I am %s, I work at %s. Call me on %s\n", e.name,
33 		e.company, e.phone) //Yes you can split into 2 lines here.
34 }
35 
36 // Interface Men implemented by Human, Student and Employee
37 type Men interface {
38 	SayHi()
39 	Sing(lyrics string)
40 }
41 
42 func main() {
43 	mike := Student{Human{"Mike", 25, "222-222-XXX"}, "MIT", 0.00}
44 	paul := Student{Human{"Paul", 26, "111-222-XXX"}, "Harvard", 100}
45 	sam := Employee{Human{"Sam", 36, "444-222-XXX"}, "Golang Inc.", 1000}
46 	tom := Employee{Human{"Sam", 36, "444-222-XXX"}, "Things Ltd.", 5000}
47 
48 	// define interface i
49 	var i Men
50 
51 	//i can store Student
52 	i = mike
53 	fmt.Println("This is Mike, a Student:")
54 	i.SayHi()
55 	i.Sing("November rain")
56 
57 	//i can store Employee
58 	i = tom
59 	fmt.Println("This is Tom, an Employee:")
60 	i.SayHi()
61 	i.Sing("Born to be wild")
62 
63 	// slice of Men
64 	fmt.Println("Let's use a slice of Men and see what happens")
65 	x := make([]Men, 3)
66 	// these three elements are different types but they all implemented interface Men
67 	x[0], x[1], x[2] = paul, sam, mike
68 
69 	for _, value := range x {
70 		value.SayHi()
71 	}
72 }

An interface is a set of abstract methods, and can be implemented by non-interface types. It cannot therefore implement itself.

Empty interface

An empty interface is an interface that doesn’t contain any methods, so all types implement an empty interface. This fact is very useful when we want to store all types at some point, and is similar to void* in C.

1 // define a as empty interface
2 var a interface{}
3 var i int = 5
4 s := "Hello world"
5 // a can store value of any type
6 a = i
7 a = s

If a function uses an empty interface as its argument type, it can accept any type; if a function uses empty interface as its return value type, it can return any type.

Method arguments of an interface

Any variable can be used in an interface. So how can we use this feature to pass any type of variable to a function?

For example we use fmt.Println a lot, but have you ever noticed that it can accept any type of argument? Looking at the open source code of fmt, we see the following definition.

1 type Stringer interface {
2 	String() string
3 }

This means any type that implements interface Stringer can be passed to fmt.Println as an argument. Let’s prove it.

file: code/Interface/Stringer/stringer.go

 1 package main
 2 
 3 import (
 4 	"fmt"
 5 	"strconv"
 6 )
 7 
 8 type Human struct {
 9 	name  string
10 	age   int
11 	phone string
12 }
13 
14 // Human implemented fmt.Stringer
15 func (h Human) String() string {
16 	return "Name:" + h.name + ", Age:" + strconv.Itoa(h.age) + " years, Contact:" + h.p\
17 hone
18 }
19 
20 func main() {
21 	Bob := Human{"Bob", 39, "000-7777-XXX"}
22 	fmt.Println("This Human is : ", Bob)
23 }

Looking back to the example of Box, you will find that Color implements interface Stringer as well, so we are able to customize the print format. If we don’t implement this interface, fmt.Println prints the type with its default format.

1 fmt.Println("The biggest one is", boxes.BiggestsColor().String())
2 fmt.Println("The biggest one is", boxes.BiggestsColor())

Attention: If the type implemented the interface error, fmt will call error(), so you don’t have to implement Stringer at this point.

Type of variable in an interface

If a variable is the type that implements an interface, we know that any other type that implements the same interface can be assigned to this variable. The question is how can we know the specific type stored in the interface. There are two ways which I will show you.

• Assertion of Comma-ok pattern

Go has the syntax value, ok := element.(T). This checks to see if the variable is the type that we expect, where “value” is the value of the variable, “ok” is a variable of boolean type, “element” is the interface variable and the T is the type of assertion.

If the element is the type that we expect, ok will be true, false otherwise.

Let’s use an example to see more clearly.

file: code/Interface/Person/person.go

 1 package main
 2 
 3 import (
 4 	"fmt"
 5 	"strconv"
 6 )
 7 
 8 type Element interface{}
 9 type List []Element
10 
11 type Person struct {
12 	name string
13 	age  int
14 }
15 
16 func (p Person) String() string {
17 	return "(name: " + p.name + " - age: 	" + strconv.Itoa(p.age) + " years)"
18 }
19 
20 func main() {
21 	list := make(List, 3)
22 	list[0] = 1       // an int
23 	list[1] = "Hello" // a string
24 	list[2] = Person{"Dennis", 70}
25 
26 	for index, element := range list {
27 		if value, ok := element.(int); ok {
28 			fmt.Printf("list[%d] is an int and its value is %d\n", index, value)
29 		} else if value, ok := element.(string); ok {
30 			fmt.Printf("list[%d] is a string and its value is %s\n", index, value)
31 		} else if value, ok := element.(Person); ok {
32 			fmt.Printf("list[%d] is a Person and its value is %s\n", index, value)
33 		} else {
34 			fmt.Printf("list[%d] is of a different type\n", index)
35 		}
36 	}
37 }

It’s quite easy to use this pattern, but if we have many types to test, we’d better use switch.

• switch test

Let’s use switch to rewrite the above example.

file: code/Interface/switch/switch.go

 1 package main
 2 
 3 import (
 4 	"fmt"
 5 	"strconv"
 6 )
 7 
 8 type Element interface{}
 9 type List []Element
10 
11 type Person struct {
12 	name string
13 	age  int
14 }
15 
16 func (p Person) String() string {
17 	return "(name: " + p.name + " - age: " + strconv.Itoa(p.age) + " years)"
18 }
19 
20 func main() {
21 	list := make(List, 3)
22 	list[0] = 1       //an int
23 	list[1] = "Hello" //a string
24 	list[2] = Person{"Dennis", 70}
25 
26 	for index, element := range list {
27 		switch value := element.(type) {
28 		case int:
29 			fmt.Printf("list[%d] is an int and its value is %d\n", index, value)
30 		case string:
31 			fmt.Printf("list[%d] is a string and its value is %s\n", index, value)
32 		case Person:
33 			fmt.Printf("list[%d] is a Person and its value is %s\n", index, value)
34 		default:
35 			fmt.Println("list[%d] is of a different type", index)
36 		}
37 	}
38 }

One thing you should remember is that element.(type) cannot be used outside of the switch body, which means in that case you have to use the comma-ok pattern .

Embedded interfaces

The most beautiful thing is that Go has a lot of built-in logic syntax, such as anonymous fields in struct. Not suprisingly, we can use interfaces as anonymous fields as well, but we call them Embedded interfaces. Here, we follow the same rules as anonymous fields. More specifically, if an interface has another interface embedded within it, it will behave as if it has all the methods that the embedded interface has.

We can see that the source file in container/heap has the following definition:

1 type Interface interface {
2 	sort.Interface      // embedded sort.Interface
3 	Push(x interface{}) //a Push method to push elements into the heap
4 	Pop() interface{}   //a Pop method that pops elements from the heap
5 }

We see that sort.Interface is an embedded interface, so the above Interface has the three methods contained within the sort.Interface implicitly.

1 type Interface interface {
2 	// Len is the number of elements in the collection.
3 	Len() int
4 	// Less returns whether the element with index i should sort
5 	// before the element with index j.
6 	Less(i, j int) bool
7 	// Swap swaps the elements with indexes i and j.
8 	Swap(i, j int)
9 }

Another example is the io.ReadWriter in package io.

1 // io.ReadWriter
2 type ReadWriter interface {
3 	Reader
4 	Writer
5 }

Reflection

Reflection in Go is used for determining information at runtime. We use the reflect package, and this official article explains how reflect works in Go.

There are three steps involved when using reflect. First, we need to convert an interface to reflect types (reflect.Type or reflect.Value, this depends on the situation).

1 t := reflect.TypeOf(i)    // get meta-data in type i, and use t to get all elements
2 v := reflect.ValueOf(i)   // get actual value in type i, and use v to change its val\
3 ue

After that, we can convert the reflected types to get the values that we need.

1 var x float64 = 3.4
2 v := reflect.ValueOf(x)
3 fmt.Println("type:", v.Type())
4 fmt.Println("kind is float64:", v.Kind() == reflect.Float64)
5 fmt.Println("value:", v.Float())

Finally, if we want to change the values of the reflected types, we need to make it modifiable. As discussed earlier, there is a difference between pass by value and pass by reference. The following code will not compile.

1 var x float64 = 3.4
2 v := reflect.ValueOf(x)
3 v.SetFloat(7.1)

Instead, we must use the following code to change the values from reflect types.

1 var x float64 = 3.4
2 p := reflect.ValueOf(&x)
3 v := p.Elem()
4 v.SetFloat(7.1)

Links

-Previous section -Next section

Concurrency

goroutine

goroutines and concurrency are built into the core design of Go. They’re similar to threads but work differently. More than a dozen goroutines maybe only have 5 or 6 underlying threads. Go also gives you full support to sharing memory in your goroutines. One goroutine usually uses 4~5 KB of stack memory. Therefore, it’s not hard to run thousands of goroutines on a single computer. A goroutine is more lightweight, more efficient and more convenient than system threads.

goroutines run on the thread manager at runtime in Go. We use the go keyword to create a new goroutine, which is a function at the underlying level ( main() is a goroutine ).

1 go hello(a, b, c)

Let’s see an example.

 1 package main
 2 
 3 import (
 4 	"fmt"
 5 	"runtime"
 6 )
 7 
 8 func say(s string) {
 9 	for i := 0; i < 5; i++ {
10 		runtime.Gosched()
11 		fmt.Println(s)
12 	}
13 }
14 
15 func main() {
16 	go say("world") // create a new goroutine
17 	say("hello") // current goroutine
18 }

Output：

1 hello
2 world
3 hello
4 world
5 hello
6 world
7 hello
8 world
9 hello

We see that it’s very easy to use concurrency in Go by using the keyword go. In the above example, these two goroutines share some memory, but we would better off following the design recipe: Don’t use shared data to communicate, use communication to share data.

runtime.Gosched() means let the CPU execute other goroutines, and come back at some point.

The scheduler only uses one thread to run all goroutines, which means it only implements concurrency. If you want to use more CPU cores in order to take advantage of parallel processing, you have to call runtime.GOMAXPROCS(n) to set the number of cores you want to use. If n<1, it changes nothing. This function may be removed in the future, see more details about parallel processing and concurrency in this article.

channels

goroutines run in the same memory address space, so you have to maintain synchronization when you want to access shared memory. How do you communicate between different goroutines? Go uses a very good communication mechanism called channel. channel is like a two-way pipeline in Unix shells: use channel to send or receive data. The only data type that can be used in channels is the type channel and the keyword chan. Be aware that you have to use make to create a new channel.

1 ci := make(chan int)
2 cs := make(chan string)
3 cf := make(chan interface{})

channel uses the operator <- to send or receive data.

1 ch <- v    // send v to channel ch.
2 v := <-ch  // receive data from ch, and assign to v

Let’s see more examples.

 1 package main
 2 
 3 import "fmt"
 4 
 5 func sum(a []int, c chan int) {
 6 	total := 0
 7 	for _, v := range a {
 8 	total += v
 9 	}
10 	c <- total  // send total to c
11 }
12 
13 func main() {
14 	a := []int{7, 2, 8, -9, 4, 0}
15 
16 	c := make(chan int)
17 	go sum(a[:len(a)/2], c)
18 	go sum(a[len(a)/2:], c)
19 	x, y := <-c, <-c  // receive from c
20 
21 	fmt.Println(x, y, x + y)
22 }

Sending and receiving data in channels blocks by default, so it’s much easier to use synchronous goroutines. What I mean by block is that a goroutine will not continue when receiving data from an empty channel, i.e (value := <-ch), until other goroutines send data to this channel. On the other hand, the goroutine will not continue until the data it sends to a channel, i.e (ch<-5), is received.

Buffered channels

I introduced non-buffered channels above. Go also has buffered channels that can store more than a single element. For example, ch := make(chan bool, 4), here we create a channel that can store 4 boolean elements. So in this channel, we are able to send 4 elements into it without blocking, but the goroutine will be blocked when you try to send a fifth element and no goroutine receives it.

1 ch := make(chan type, n)
2 
3 n == 0 ! non-buffer（block）
4 n > 0 ! buffer（non-block until n elements in the channel）

You can try the following code on your computer and change some values.

 1 package main
 2 
 3 import "fmt"
 4 
 5 func main() {
 6 	c := make(chan int, 2)  // change 2 to 1 will have runtime error, but 3 is fine
 7 	c <- 1
 8 	c <- 2
 9 	fmt.Println(<-c)
10 	fmt.Println(<-c)
11 }

Range and Close

We can use range to operate on buffer channels as in slice and map.

 1 package main
 2 
 3 import (
 4 	"fmt"
 5 )
 6 
 7 func fibonacci(n int, c chan int) {
 8 	x, y := 1, 1
 9 	for i := 0; i < n; i++ {
10 		c <- x
11 		x, y = y, x + y
12 	}
13 	close(c)
14 }
15 
16 func main() {
17 	c := make(chan int, 10)
18 	go fibonacci(cap(c), c)
19 	for i := range c {
20 		fmt.Println(i)
21 	}
22 }

for i := range c will not stop reading data from channel until the channel is closed. We use the keyword close to close the channel in above example. It’s impossible to send or receive data on a closed channel; you can use v, ok := <-ch to test if a channel is closed. If ok returns false, it means the there is no data in that channel and it was closed.

Remember to always close channels in producers and not in consumers, or it’s very easy to get into panic status.

Another thing you need to remember is that channels are not like files. You don’t have to close them frequently unless you are sure the channel is completely useless, or you want to exit range loops.

Select

In the above examples, we only use one channel, but how can we deal with more than one channel? Go has a keyword called select to listen to many channels.

select is blocking by default and it continues to execute only when one of channels has data to send or receive. If several channels are ready to use at the same time, select chooses which to execute randomly.

 1 package main
 2 
 3 import "fmt"
 4 
 5 func fibonacci(c, quit chan int) {
 6 	x, y := 1, 1
 7 	for {
 8 		select {
 9 		case c <- x:
10 			x, y = y, x + y
11 		case <-quit:
12 		fmt.Println("quit")
13 			return
14 		}
15 	}
16 }
17 
18 func main() {
19 	c := make(chan int)
20 	quit := make(chan int)
21 	go func() {
22 		for i := 0; i < 10; i++ {
23 			fmt.Println(<-c)
24 		}
25 		quit <- 0
26 	}()
27 	fibonacci(c, quit)
28 }

select has a default case as well, just like switch. When all the channels are not ready for use, it executes the default case (it doesn’t wait for the channel anymore).

1 select {
2 case i := <-c:
3 	// use i
4 default:
5 	// executes here when c is blocked
6 }

Timeout

Sometimes a goroutine becomes blocked. How can we avoid this to prevent the whole program from blocking? It’s simple, we can set a timeout in the select.

 1 func main() {
 2 	c := make(chan int)
 3 	o := make(chan bool)
 4 	go func() {
 5 		for {
 6 			select {
 7 				case v := <- c:
 8 					println(v)
 9 				case <- time.After(5 * time.Second):
10 					println("timeout")
11 					o <- true
12 					break
13 			}
14 		}
15 	}()
16 	<- o
17 }

Runtime goroutine

The package runtime has some functions for dealing with goroutines.

• runtime.Goexit()

  Exits the current goroutine, but defered functions will be executed as usual.

• runtime.Gosched()

  Lets the scheduler execute other goroutines and comes back at some point.

• runtime.NumCPU() int

  Returns the number of CPU cores

• runtime.NumGoroutine() int

  Returns the number of goroutines

• runtime.GOMAXPROCS(n int) int

  Sets how many CPU cores you want to use

Links

-Previous section -Next section

Managing the Workspace

$GOPATH and $GOROOT

$GOROOT: This is an environment variable which stores the path where your Go installation is present if you have customized it. $GOPATH: The Go universe for your machine. The idea is that all your Go code should reside in a directory tree so the code isn’t lying around in random places.

My $GOPATH is /usr/home/suraj/Go, it has the following structure - pkg: The libraries which’ll be imported in our code, there is a .a file created at the respective path. - bin: The binary file of our project will be installed here on calling go install in the project folder - src: Will hold the actual code, if you have a github account, then you can create a folder tree inside like

go - src - github.com - thewhitetulip - wshare - picsort - golang.net - sourcegraph.com - bin (binaries) - wshare - picsort - pkg

Go takes this unique approach so that all the Go code is well organized and not thrown in a haphazard manner. This makes it easy to locate code for humans and software alike.

Packages

Packages are one or more file(s) which contains Go source code. They can be named anything. Each package except the main needs to be a in a distinct folder on the GOPATH. Each Go program starts with the package declaration. As a convention, package names are short and self documenting. The Format package is called fmt since it is short and concise that way.

There can be any number of files in a package directory, but only one file with the main function. While building the code, the compiler starts with the main function in the main package.

Package naming

import "views"

When the Go compiler executes this statement, it’ll try to find the library called “views” in $GOROOT/views or $GOPATH/src/views. It’ll complain if it doesn’t find the library in either of the two paths.

The actual package name is just “views”, but for evaluating it, it’s the absolute path of the package from the $GOPATH/src directory.

For the Tasks app, it resides in $GOPATH/src/github/thewhitetulip/Tasks, thus, my packages will lie within the Tasks folder. This makes it easy for distributing the libraries.

Note: Bad Workaround.

There is a workaround for this by treating $GOPATH/src itself as your entire project and having libraries directly inside it. This is not the Go way of doing things. Please do not do it.

Internal deployment

We’ll follow the standard practice and put our code in $GOPATH/src/github.com/thewhitetulip/Tasks folder. While testing our app, we need a deployment version. I used Tasks while building Tasks, I have made a folder ~/Tasks and here I keep the deployment version of Tasks, which contains the binary version and the static files. Every new build in the src gets pushed in this folder.

Running a server

Webapps are deployed on IP addresses & ports. It is possible to run multiple websites on a single machine on different ports. There are an awfully large number of ports on each computer. Typically we choose a large port number like 8000 so it doesn’t affect some other applications. Certain ports are restricted and need sudo access, like 80.

The IP address we bind the server to can be a public or private. Public means using “:8080” or “0.0.0.0:8080”. Private means “127.0.0.1:8080”

• Public IP means that any computer in the same network can access the web app.
• Private means only your computer will be able to access it.

//Public

log.Fatal(http.ListenAndServe(":8080", nil))

//Private

log.Fatal(http.ListenAndServe("127.0.0.1:8080", nil))

Note: 127.0.0.1

127.0.0.1, called localhost, is a special IP address which is given to every machine to refer to itself. It is called as loopback address. It doesn’t matter if you are connected to the network or not, your machine will always have this IP address, so if you are want privacy use 127.0.0.1.

If you do want your web application to be accessible via the network, use 0.0.0.0:8080 or just :8080, when you give just the port number, the Go language assumes the IP address the machine is ‘0.0.0.0’ and not 127.0.0.1.

MVC Pattern

When I started learning building web apps in Django, I first read about the MVC pattern, the models, the views and what not. But that knowledge was to be assumed by me and I had no idea why that decision was made, along with that Django works like magic, one has to adapt to it’s quirks. Hence while programming in Go, it’ll be immensely benefitial to grow up to the MVC pattern by starting out small. The first app should entirely reside in the main.go file, then slowly, as the app grows, it needs to be structured well, so the all the handlers go into a views package, templates go in a templates folder, database related entities go in another package.

Learning by doing and experimenting is the best way. Challenge the status quo.

Links

-Previous section -Next section

Web Programming Basics

Web servers are programs which accept a HTTP Request and they respond back with a HTTP Response.The Go language has http support in it’s standard library as net/http.

HTTP was built for transferring plain text, later it allowed multimedia content too. The successor of HTTP protocol is HTTP2, which is binary.

When we type www.github.com on our browser’s address bar, the following things happen:

1. Browser adds either https:// or http:// and a trailing forward slash.
2. Our request becomes GET / github.com. (This is the HTTP Request)
3. Browser sends out the HTTP GET request to the IP address of the github.com. Resolving the IP address of a domain name is called DNS resolution.
4. Github’s servers will process the request and send back a response to our IP address.
5. Our browser will render the HTTP Response.

The HTTP Response contains the status code of the request. Following are the status codes defined in HTTP/1.1:

• 1xx Informational
• 2xx Success
• 3xx Redirection
• 4xx Client Error
• 5xx Server Error

Writing a server might sound like very difficult, but it is not. To the core, a server is just like any other program you write. It takes an input, transforms it and gives an output. The input is a HTTP Request, the transformation happens when it reads data from the database and does processing over the HTTP Request, the output is the HTTP Response.

The browser just abstracts the users from sending and receiving the HTTP request/responses. Everything that a browser does can be done programmatically,

HTTP Methods

Two important parts of a HTTP Request are Methods and URL. The URL states what the user wants to do (/logout or /login or /posts), and the Method states the semantics of the request, for instance the user might be sending a Form using the POST method or the user is wanting a list of posts using the GET method.

A short list of HTTP methods: GET, POST, DELETE, PUT.

1. GET : Used to retrieve the URL, GET / will get the home page.
2. POST: Used to create data stored on the URL.
3. PUT: Used to update data on the URL. PUT differs from POST in a crucial way, PUT is idempotent, if you send a PUT request twice, then it won’t be duplicated. If you send a POST request twice, then it’ll create two resources on the server, thus, POST creates duplicates on two exactly same requests, PUT does not.
4. DELETE: Used to delete data in the URL.

This is going to be our server design, the Methods and URLs that we are going to support.

 1 // Create a new category.
 2 // POST /categories
 3 
 4 // Update an existing category.
 5 // PUT /categories/12
 6 
 7 // View the details of a category.
 8 // GET /categories/12   
 9 
10 // Delete an existing category.
11 // DELETE /categories/12

Think of categories as a document,

1. POST to create it
2. GET to fetch it,
3. PUT to update it,
4. DELETE to delete it.

Of course, instead of using the DELETE method, we can use the GET method to perform the same task sending a GET /delete/1234, but, we should send a DELETE `/tasks/1234. This comes under API design. PUT and DELETE are used when we are working with AJAX.

GET vs POST

Apart from their functional differences, GET and POST differ in security perspectives. Basically, both are insecure. There is no free lunch in security.

GET transfers data via the URL. POST sends data in the request’s body or payload, but that isn’t hidden or encrypted by default, but it isn’t visible on the URL, it is easily accessible to anyone who knows how to read a HTTP request.

Security is something you build your application around. There isn’t much difference between GET and POST when we consider security, both transfer data in plain text GET is just relatively a little less secure since URLs are logged by a proxy server/firewall/browser history and that GET requests can be done by the browser on behalf of the user without confirmation. For protecting data of the webapp, one has to stick to using HTTPS and sanitize any data that comes from the user.

Example

A blog consists of a collection of posts, a post has tags, is written by some author, at some time and has some primary key to uniquely identify it in our database and it has a slug which means the URL.

This is the era of semantic web, thus the new beautiful URLs like, someblog.com/posts/welcome-the-new-year, the slug is the welcome-the-new-year.

When the server gets a HTTP GET request of /posts/welcome-the-new-year, it’ll search for URL handlers starting with the list of URL handlers we have given, then it’ll find the closest match, in our case it’ll be /post/, then it’ll call the handler of this URL. A handler is nothing but a function we have written to process a particular URL pattern.

Our / root URL should be at the very bottom of our list. Because while executing, checks are done from top to bottom.

1     // sample handler definition
2     http.HandleFunc("/post/", ShowPostBySlug)
3     http.HandleFunc("/", ShowAllPosts)

Handlers talk to the database, fetch the data and render templates which show up as HTML pages in our browser.

What is a template?

Templates are a way to present data to the user. The server populates the templates and sends the HTML page back to the browser. For a blog, it doesn’t make sense to use a separate html page for each post. This is why there is a post template and the server will get all the details like content, title, date published and populate the post template and return it back to the browser.

A web application is basically a way of representing data stored in the database to the end user using HTTP.

Writing a web application:

1. Understand how data flows and decide the URLs.
2. Fix the database structure.
3. Write templates to corresponding to each URL set.
4. Write functions in Go to handle each URL pattern, called handlers.
5. Handlers fetch data from the database and populate data in the templates.

Not abusing templates

The logic behind creating templates was to avoid duplication of HTML code. Templates are to be used only for the presentation logic not the business logic. Adding business logic in templates makes it very difficult to maintain the app.

Example:

We are going to build a todo list manager in this book with supports multiple users.

Wrong way: Fetch all tasks in the template and only show those of the current user. i.e. filter the tasks in the template

Correct way: Fetch only the tasks belonging to the current user. i.e. filter the tasks in the handler.

Functionality of our EditTask URL which is /edit/<id>.

file views/addViews.go

1 //EditTaskFunc is our handler which will handle the /edit/<id> URL
2 func EditTaskFunc(w http.ResponseWriter, r *http.Request) {
3         //Code
4         task := db.GetTaskByID(id)
5         editTemplate.Execute(w, task)
6         //Code
7 }

file db/tasks.go

1 func GetTaskByID(id int) types.Context {
2         //Code to fetch tasks of the current user
3         context := types.Context{Tasks: tasks}
4         return context
5 }

The EditTaskFunc talks to the database with the GetTaskByID function and fetches the tasks for the current user and populates the editTemplate.

Thus we can split an application into views, database, templates and controller(main package).

Static Files

Static files are the CSS/JS/Images which we load into our html templates.

The URL which responds to static files will be /static/.

Execution:

1. We get a request like /static/<filepath>
2. We go to the public directory of our application and look for <filepath>
3. If we get a file of that path then we serve the file, othewise send a 404 error.

The public folder contains all your static files. We will have a templates folder on the same folder where the public is present.

The reason templates is a separate folder is that it is a separate entity and shouldn’t be publicly available using the /static/ URL.

 1     public
 2     |   |-- static
 3     |   |   |-- css
 4     |   |   |   `-- styles.css
 5                     ..and more
 6     |   |   `-- js
 7     |   |       |-- bootstrap.min.js
 8     |   |       .... and more
 9     templates
10     |   |-- completed.html
11     |   |   ...and more        

Note

The above output is of the tree program.

Links

-Previous section -Next section

Basic web application

Make a folder in your $GOPATH/src/github.com/<yourname>/Tasks substitute your username in lieu of <yourname>.

Create a file main.go

file main.go

 1 package main
 2 
 3 import (
 4 	"log"
 5 	"net/http"
 6 )
 7 
 8 func main() {
 9 	PORT := "127.0.0.1:8080"
10 	log.Fatal(http.ListenAndServe(PORT, nil))
11 }

We import the http package in our application with import net/http.

Now go to your terminal and type

1 	[Tasks] $ go run main.go

You will notice that the program doesn’t print anything because we told it only to listen on the port. If we want to user to know that we are running a server on that port, we should print a message saying so, as shown in the below example.

code example file: 3.1basicServer.go

 1 package main
 2 
 3 import (
 4 	"log"
 5 	"net/http"
 6 )
 7 
 8 func main() {
 9 	PORT := ":8080"
10 	log.Print("Running server on "+ PORT)
11 	log.Fatal(http.ListenAndServe(PORT, nil))
12 } 

Whenever we run this, we’ll get the below output

1 	2016/01/01 22:00:36 Running server on :8080

Open localhost:8080 in a browser and you’ll get the message “404 page not found”

We have just started a server to listen on the port 8080. We haven’t handled the URL, i.e. we do not have a mechanism to respond to the GET / request which the browser is going to send when we hit the localhost:8080 URL.

Handling URLs

1 http.HandleFunc("/complete/", ShowCompleteTasksFunc)
2 
3 //ShowCompleteTasksFunc is used to populate the "/completed/" URL
4 func ShowCompleteTasksFunc(w http.ResponseWriter, r *http.Request) {
5 }

We use HandleFunc in the net/http package to handle URLs. The first argument is the URL to be handled and the second parameter is the function. We can define functions in the second parameter, but you are advised against it.

The handler function requires two arguments, a ResponseWriter object and a Request object. We are going to write to the ResponseWriter depending on what we get in the Request object. The ResponseWriter object is going to be the output, Request object is the input. The handler which we are writing is going to write data to the ResponseWriter object, which will be sent back to the user’s browser.

Handler Example

We want to write the URL that the user is visiting on our webapp. The URL can be found in the request object, r.URL.Path.

 1 package main
 2 
 3 import (
 4 	"log"
 5 	"net/http"
 6 )
 7 
 8 func main() {
 9 	PORT := ":8080"
10 	log.Print("Running server on "+ PORT)
11 	http.HandleFunc("/",CompleteTaskFunc)
12 	log.Fatal(http.ListenAndServe(PORT, nil))
13 }
14 
15 func CompleteTaskFunc(w http.ResponseWriter, r *http.Request) {
16 	w.Write([]byte(r.URL.Path))
17 }

Parameterized routing

When we get the URL /tasks/124, we want to get the task number 124, we do the following

1 //GetTaskFunc is used to get a task
2 func GetTaskFunc(w http.ResponseWriter, r *http.Request) {
3 	if r.Method == "GET" {
4 		id := r.URL.Path[len("/tasks/"):]
5 		w.Write([]byte("Get the task "+id))
6 }

We take a sub string of the URL and remove the /tasks/ part to get the ID of the task.

This example makes use of the slicing concept. It is simple, if Path is our string variable then Path[1:] is the substring which includes everything from the first character, index being zero.

Note: Parameterized routing

Ideally we should not be checking the URL path inside our view, we are supposed to use a router. For real projects, you should use a router. But before we start using third party libraries, it is better to learn the concepts, hence, we won’t be using a router now.

Serving static files

1 http.Handle("/static/", http.FileServer(http.Dir("public")))

For serving static files, we use the FileServer method of the http package. It takes a folder as an argument. Make sure you give only the public folder path in the argument.

Homework

• Read the documentation of net/http & log and get to know of the methods/functions in the packages.
• Find out how many alternatives are there to ListenAndServe.
• Write a handler to serve static files, if file is available on that path then it should serve the file, otherwise it must return an HTTP404 error.
• Write a command line application to share files/folder over HTTP, the syntax should be like this ./wshare -f file.pdf file on link = 192.168.2.1:8080. An advanced version of this can be a dropbox clone, where we have a UI to share files. If you build this, do email me!

Footnotes

Learn how to read documentation, it saves a lot of time.

Links

-Previous section -Next section

Designing our web app

The design phase is the most important in any software project as one small mistake in designing becomes very costly to fix that later. In most projects, there are a few solutions applied to mistakes in design, they are just glued together until it becomes impossible to go forward. The term is called technical debt.

Our webapp is going to be a todo list manager for multiple users. It’ll have the following features:

1 Ability to add/delete/modify task.
2 Ability to mark tasks as complete/incomplete.
3 Display the tasks as a one column list.
4 Ability to switch modes between pending/completed/deleted tasks.
5 Display notifications like note added/deleted/archived. 
6 Search for text and highlight the text in the search results page.
7 Login/Sign up.

The Design

Translating our design to API, we get the following.

file ~/main/main.go

 1 package main
 2 import (
 3     "log"
 4     "net/http"
 5 )
 6 
 7 func main() {
 8     http.HandleFunc("/complete/", CompleteTaskFunc)
 9     http.HandleFunc("/delete/", DeleteTaskFunc)
10     http.HandleFunc("/deleted/", ShowTrashTaskFunc)
11     http.HandleFunc("/trash/", TrashTaskFunc)
12     http.HandleFunc("/edit/", EditTaskFunc)
13     http.HandleFunc("/completed/", ShowCompleteTasksFunc)
14     http.HandleFunc("/restore/", RestoreTaskFunc)
15     http.HandleFunc("/add/", AddTaskFunc)
16     http.HandleFunc("/update/", UpdateTaskFunc)
17     http.HandleFunc("/search/", SearchTaskFunc)
18     http.HandleFunc("/login", GetLogin)
19     http.HandleFunc("/register", PostRegister)
20     http.HandleFunc("/admin", HandleAdmin)
21     http.HandleFunc("/add_user", PostAddUser)
22     http.HandleFunc("/change", PostChange)
23     http.HandleFunc("/logout", HandleLogout)
24     http.HandleFunc("/", ShowAllTasksFunc)
25 
26     http.Handle("/static/", http.FileServer(http.Dir("public")))
27     log.Print("running on port 8080")
28     log.Fatal(http.ListenAndServe(":8080", nil))
29 }

Create all functions we mentioned above and make the necessary changes as per one definition that we show below in this file.

1 func ShowAllTasksFunc(w http.ResponseWriter, r *http.Request) {
2     var message string
3     if r.Method == "GET" {
4         message = "all pending tasks GET"
5     } else {
6         message = "all pending tasks POST"
7     }
8     w.Write([]byte(message))
9 }

After you create these functions run the server as below,

1 [Tasks] $ go build
2 [Tasks] $ ./Tasks

In your browser type localhost:8080 and type all these URLs and see what message you get.

Homework

Check the documentation for http.ResponseWriter and http.Request objects and get to know all the variables/functions/constants for http package and these two which we mentioned.

Links

-Previous section -Next section

Using databases in Go

Go doesn’t provide out of the box support for any database, but it provides an interface, which can be used by database library creators to keep all the database libraries compatible with each other.

We will use sqlite for this book.

Creating and configuring database

Before we can build the front end, we need the backend ready. Below is the DDL and the DML which will fill our database with dummy data.

Use the following insert statements to enter data in our table, so we’ll begin reading data in our ShowAllTasks function which we wrote in the previous chapter

 1       --user
 2 
 3     PRAGMA foreign_keys=OFF;
 4     BEGIN TRANSACTION;
 5     CREATE TABLE user (
 6         id integer primary key autoincrement,
 7         username varchar(100),
 8         password varchar(1000),
 9         email varchar(100)
10     );
11     INSERT INTO "user" VALUES(1,'suraj','suraj','sapatil@live.com');
12 
13 
14     --category
15     CREATE TABLE category( 
16         id integer primary key autoincrement,
17         name varchar(1000) not null, 
18         user_id references user(id)
19     );
20 
21     INSERT INTO "category" VALUES(1,'TaskApp',1);
22 
23     --status
24     PRAGMA foreign_keys=OFF;
25     BEGIN TRANSACTION;
26     CREATE TABLE status (
27         id integer primary key autoincrement,
28         status varchar(50) not null
29     );
30     INSERT INTO "status" VALUES(1,'COMPLETE');
31     INSERT INTO "status" VALUES(2,'PENDING');
32     INSERT INTO "status" VALUES(3,'DELETED');
33     COMMIT;
34 
35     --task
36 
37     PRAGMA foreign_keys=OFF;
38     BEGIN TRANSACTION;
39     CREATE TABLE task (
40         id integer primary key autoincrement,
41         title varchar(100),
42         content text,
43         created_date timestamp,
44         last_modified_at timestamp,
45         finish_date timestamp,
46         priority integer, 
47         cat_id references category(id), 
48         task_status_id references status(id), 
49         due_date timestamp, 
50         user_id references user(id), 
51         hide int
52     );
53 
54     INSERT INTO "task" VALUES(1,'Publish on github','Publish the source of tasks and\
55  picsort on github','2015-11-12 15:30:59','2015-11-21 14:19:22','2015-11-17 17:02:18\
56 ',3,1,1,NULL,1,0);
57     INSERT INTO "task" VALUES(4,'gofmtall','The idea is to run gofmt -w file.go on e\
58 very go file in the listing, *Edit turns out this is is difficult to do in golang **\
59 Edit barely 3 line bash script. ','2015-11-12 16:58:31','2015-11-14 10:42:14','2015-\
60 11-13 13:16:48',3,1,1,NULL,1,0);
61 
62     CREATE TABLE comments(id integer primary key autoincrement, content ntext, taskI\
63 D references task(id), created datetime, user_id references user(id));
64 
65     CREATE TABLE files(name varchar(1000) not null, autoName varchar(255) not null, \
66 user_id references user(id), created_date timestamp);