A Tour of Go - Basics: More types: structs, slices, and maps.

Question 1

Does Go have pointers?

Answer 1

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

Question 2

What is the address operator?

Answer 2

The & generates a pointer to it’s operand

i := 42
p := &i

Question 3

What is the derefence operator?

Answer 3

The * operator denotes the pointer’s underlying value.

fmt.Println(*p)
*p = 21

Question 4

Does Go support pointer arithmetic like ‘C’?

Answer 4

No.

Question 5

How is a struct declared in Go?

Answer 5

A struct is a collection of fields

type Vertex struct {
	X int
	Y int
}

Question 6

How are struct fields accessed?

Answer 6

Using a dot

var v Vertex
v.X = 1
x.Y = 5

Question 7

How are fields accessed with a struct pointer?

Answer 7

To access the field X of a struct when we have the struct pointer p we could write (*p).X. However, that notation is cumbersome, so the language permits us instead to write just p.X, without the explicit dereference.

v := &Vertex{}
(*v).X = 1
v.Y = 5

Question 8

What are struct literals?

Answer 8

A struct literal denotes a newly allocated struct value by listing the values of its fields.

You can list just a subset of fields by using the Name: syntax. (And the order of named fields is irrelevant.)

The special prefix & returns a pointer to the struct value.

v1 = Vertex{1, 2}  // has type Vertex
v2 = Vertex{X: 1}  // Y:0 is implicit
v3 = Vertex{}      // X:0 and Y:0
p  = &Vertex{1, 2} // has type *Vertex

Question 9

How are arrays declared?

Answer 9

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

var a [10]int

Question 10

An array’s length is ….

Answer 10

An array’s length is part of its type, so arrays cannot be resized.

Question 11

What is a slice?

Answer 11

An array has a fixed size. A slice, on the other hand, is a dynamically-sized, flexible view into the elements of an array.

Question 12

How is a slice declared?

Answer 12

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

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

var s []int = primes[1:4]

Question 13

What is a slice literal?

Answer 13

A slice literal is like an array literal without the length.

r := []bool{true, false, true}

This creates an array then builds a slice that references it.

Question 14

What are the defaults for a slice lower bound?

Answer 14

zero

Question 15

What is the default for a slice upper bound?

Answer 15

The length of the array - len(s)

Question 16

What is the length of a slice?

Answer 16

The length of a slice is the number of elements it contains.

len(s)

Question 17

What is the capacity of the slice?

Answer 17

The capacity of a slice is the number of elements in the underlying array, counting from the first element in the slice.

cap(s)

Question 18

Whats the zero value of a slice?

Answer 18

The zero value of a slice is nil.

A nil slice has a length and capacity of 0 and has no underlying array.

Question 19

In Go, how can you create a dynamically-sized array?

Answer 19

Use the built-in make function. The make function allocates a zeroed array and returns a slice that refers to that array:

a := make([]int, 5) // len(a)=5

Question 20

What is the 3rd argument to the built-in `make function?

Answer 20

To specify a capacity, pass a third argument to make:

b := make([]int, 0, 5) // len(b)=0, cap(b)=5

Question 21

What types can a slice contain?

Answer 21

Any, including other slices.

// Create a tic-tac-toe board.
board := [][]string{
    []string{"_", "_", "_"},
    []string{"_", "_", "_"},
    []string{"_", "_", "_"},
}

Question 22

How can you append elements to a slice?

Answer 22

Go provides a built-in function append. The first parameter s of append is a type T, and the rest are T values to append to the slice.

If the backing array of s is too small to fit all the given values a bigger array will be allocated. The returned slice will point to the newly allocated array.

Question 23

How do you iterate over a slice?

Answer 23

The range form of the for loop iterates over a slice.

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 at that index.

for i, v := range s {
    fmt.Printf("s[%d] = %d\n", i, v)
}

Question 24

With a range for loop can you skip the index or value?

Answer 24

You can skip the index or value by assigning to _.

for i, _ := range pow
for _, value := range pow

If you only want the index, you can omit the second variable.

for i := range pow

Question 25

In Go, what is a map?

Answer 25

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 a given type initialised and ready for use. ``` var m map[string]string m = make(map[string]string) ```

Question 26

What is a map literal?

Answer 26

A map literals are like struct literals, but the keys are required. ``` var m = map[string]Vertex{ "Bell Labs": Vertex{ 40.68433, -74.39967, }, "Google": Vertex{ 37.42202, -122.08408, }, } ```

Question 27

What can you omit from a map literal?

Answer 27

If the top-level type is just a type name, you can omit it from the elements of the literal. ``` var m = map[string]Vertex{ "Bell Labs": {40.68433, -74.39967}, "Google": { 37.42202, -122.08408}, } ```

Question 28

How do you insert or update a map element?

Answer 28

``` m[key] = elem ```

Question 29

How do you retrieve a map element?

Answer 29

``` elem = m[key] ```

Question 30

How do you delete a map element

Answer 30

delete(m, key)

Question 31

How do you test a map key is present?

Answer 31

A two-value assignment can be used: ``` elem, ok = m[key] ``` If `key` is in `m`, ok is true. if not `ok` is `false. if `key` is not in the map, then `elem` is the zero value for the map's element type.

Question 32

In Go, are functions values?

Answer 32

Yes. They can be passed around just like other values. Function values may be used as function arguments and return values. ``` 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(hypot(5, 12)) fmt.Println(compute(hypot)) fmt.Println(compute(math.Pow)) } ```

Question 33

What is a function closure?

Answer 33

A closure is a function value that references variables from outside it's body. The function may access and assign to the referenced variables; in this sense the function is "bound" to the variables.

Question 34

Give an example of a closure?

Answer 34

``` func adder() func(int) int { sum := 0 return func(x int) int { sum += x return sum } } func main() { pos, neg := adder(), adder() for i := 0; i < 10; i++ { fmt.Println( pos(i), neg(-2*i), ) } } ```

Question 35

Complete the fibonacci closure: ``` func fibonacci() func() int { } func main() { f := fibonacci() for i := 0; i < 10; i++ { fmt.Println(f()) } } ```

Answer 35

``` func fibonacci() func() int { a, b := 0, 1 return func() int { f := a a, b = a+b, f return f } } ```