Go Programming Language

Information in this section is from How to Write Go Code on the golang website.

The go tool is the standard way to fetch, build, and install Go packages and commands. Go programmers typically keep all their Go code in a single workspace. A workspace contains many version control repositories. Each repository contains one or more packages. Each package consists of one or more Go source files in a single directory.

A workspace is a directory hierarchy with three directories at its root: src, pkg, and bin. The go tool builds source packages and installs the resulting binaries to the pkg and bin directories. The src subdirectory typically contains multiple version control repositories.

The GOPATH environment variable specifies the location of your workspace.

An import path is a string that uniquely identifies a package. A package's import path corresponds to its location inside a workspace or in a remote repository. If you have a GitHub account at github.com/user, that should be your base path.

Now you can build and install a program with the go tool:

go install github.com/elliotpenson/hello

You can also omit the package path if you run go install from the package directory.

Programs start running in package main.

package main

By convention, the package name is the same as the last element of the import path. For instance, the "math/rand" package comprises files that begin with the statement package rand.

Imports can be grouped into a parenthesized, "factored" import statement.

import (
        "fmt"
        "math"
)

In Go, a name is exported if it begins with a capital letter. When importing a package, you can refer only to its exported names.

A function can take zero or more arguments.

func add(x int, y int) int {
        return x + y
}

Notice that the type comes after the variable name.

When two or more consecutive named function parameters share a type, you can omit the type from all but the last.

func add(x, y int) int {
        return x + y
}

A var statement declares a list of variables; as in function argument lists the type is last. A var statement can be at package or function level.

package main

import "fmt"

var c, python, java bool

func main() {
        var i int
        fmt.Println(i, c, python, java)
}

Go has only one looping construct, the for loop. The basic for loop looks similar to C (with three components) but without parenthesis.

for i := 0; i < 10; i++ {
        // something
}

The init and post statement are optional. At that point you can drop the semicolons: C's while is spelled for in Go.

sum := 1
for sum < 1000 {
        sum += sum
}

If you omit the loop condition it loops forever.

No need for parens in Go's if statements, but the braces are required.

if x < 0 {
        // body
}

Like for, the if statement can start with a short statement to execute before the condition. Variables declared by the statement are only in scope until the end of the if.

if v := math.Pow(x, n); v < lim {
        return v
}

A switch statement is a shorter way to write a sequence of if - else statements. It runs the first case whose value is equal to the condition expression.

Go's switch is like the one in C, except that Go only runs the selected case, not all the cases that follow.

package main

import (
        "fmt"
        "runtime"
)

func main() {
        fmt.Print("Go runs on ")
        switch os := runtime.GOOS; os {
        case "darwin":
                fmt.Println("OS X.")
        case "linux":
                fmt.Println("Linux.")
        default:
                // freebsd, openbsd,
                // plan9, windows...
                fmt.Printf("%s.", os)
        }
}

Switch cases evaluate from top to bottom, stopping when a case succeeds.

Switch without a condition is the same as switch true. This construct can be a clean way to write long if-then-else chains.

A defer statement defers the execution of a function until the surrounding function returns. The deferred call's arguments are evaluated immediately, but the function call is not executed until the surrounding function returns.

func main() {
        defer fmt.Println("world")

        fmt.Println("hello")
}

Deferred function calls are pushed onto a stack. When a function returns its deferred calls are executed in last-in-first-out order.

Go has pointers. A pointer holds the memory address of a value. The type *T is a pointer to a T value. Its zero value is nil.

var p *int

The & operator generates a pointer to its operand.

i := 42
p = &i

The * operator denotes the pointer's underlying value.

fmt.Println(*p) // read i throught the pointer p
*p = 21         // set i through the pointer p

This is known as dereferencing or indirecting.

Unlike C, Go has no pointer arithmetic.

A struct is a collection of fields.

package main

import "fmt"

type Vertex struct {
        X int
        Y int
}

func main() {
        fmt.Println(Vertex{1, 2})
}

Struct fields are accessed using a dot.

v := Vertex{1, 2}
v.X = 4
fmt.Println(v.X)

The type [n]T is an array of n values of type T. The expression

var a [10]int
a[0] = 1

primes := [6]int{2, 3, 5, 7, 11, 13}

declares a variable a as an array of ten integers. An array's length is part of its type, so arrays cannot be resized. This seems limiting, but don't worry; Go provides a convenient way of working with arrays.

An array has a fixed size. A slice, on the other hand, is a dynamically-sized, flexible view into the elements of an array. In practice, slices are much more common than arrays.

The type []T is a slice with elements of type T.

A slice is formed by specifying two indices, a low and high bound, separated by a colon:

a[low : high]

This selects a half-open range which includes the first element, but excludes the last one.

The following expression creates a slice which includes elements 1 through 3 of a:

a[1:4]

Slices are like references to arrays. A slices does not store any data, it just describes a section of an underlying array. Changing the elements of a slice modifies the corresponding elements of its underlying array. Other slices that share the same underlying array will see those changes.

The range form of the for loop iterates over a slice or map. When ranging over a slice, two values are returned for each iteration. The first is the index, and the second is a copy of the element of that index.

pow := []int{1, 2, 4, 8, 16, 32, 64, 128}
for i, v := range pow {
        fmt.Printf("2**%d = %d\n", i, v)
}

You can skip the index or value by assigning to _. If you only want the index, drop the ", value" entirely.

A map maps keys to values. The zero value of a map is nil. A nil map has no keys, nor can keys be added. The make function returns a map of the given type, initialized and ready for use.

var m map[string]Vertex
// ...
m = make(map[string]Vertex)
m["Bell Labs"] = Vertex{
        40.68433, -74.39967
}
fmt.Println(m["Bell Labs"])

Functions are values too. They can be passed around just like other values (as arguments and return values).

package main

import (
        "fmt"
        "math"
)

func compute(fn func(float64, float64) float64) float64 {
        return fn(3, 4)
}

func main() {
        hypot := func(x, y float64) float64 {
                return math.Sqrt(x*x + y*y)
        }
        fmt.Println(computer(hypot))
}

Go functions may be closures. A closure if a function value that references variables from outside its body. The function may access and assign to the referenced variables; in this sense the function is bound to the variables.

Go does not have classes. However, you can define methods on types. A method is a function with a special receiver argument. The receiver appears in its own argument list between the func keyword and the method name.

In this example, the Abs method has a receiver of type Vertex named v.

type Vertex struct {
        X, Y float64
}

func (v Vertex) Abs() float64 {
        return math.Sqrt(v.X*v.X + v.Y*v.Y)
}

func main() {
        v := Vertex{3, 4}
        fmt.Println(v.Abs())
}

A method is just a function with a receiver argument.

You can declare a method on non-struct types, too. In this example we see a numeric type MyFloat with an Abs method.

type MyFloat float64

func (f MyFloat) Abs() float64 {
        if f < 0 {
                return float64(-f)
        }
        return float64(f)
}

func main() {
        f := MyFloat(-math.Sqrt2)
        fmt.Println(f.Abs())
}

You can only declare a method with a receiver whose type is defined in the same package as the method. You cannot declare a method with a receiver whose type is defined in another package (which includes the built-in types such as int).

An interface type is defined as a set of method signatures. A value of interface type can hold any value that implements those methods.

A type implements an interface by implementing its methods. There is no explicit declaration of intent, no "implements" keyword. Implicit interfaces decouple the definition of an interface from its implementation, which could then appear in any package without prearrangement.