Arrays, Slices, and more
Structs
A struct is a collection of fields
 The keyword type is used to declare the
type of the struct
 Syntax:

 type Vertex struct {
X int
Y int
}
To access a field within a struct, use a
dot
 Syntax:

 func main() {
v := Vertex{9,5} //declare and initialize v
v.X = 4
//set X equal to 4
fmt.Println (v.X) //print out X
}
Struct Literals

You can initialize the values of the fields
within the struct when you initialize the
struct
 red := Vertex{12,12}

// X and Y equal 12
You can use the variableName: to specify
a particular value
 yellow := Vertex{Y: 66, X: 12}
//Y equals 66, X equals 12, order does not matter

Or you can implicitly assign values
 blue := Vertex{}
//X and Y are both implicitly assigned 0
Maps
A map matches keys to values
 Maps are created with make before they
are used
 Syntax:

 var myMap map [string] Vertex
 func main (){
myMap = make(map [string] Vertex)
}

Assign a key to a value like this:
 myMap [“Red”] = Vertex{12, 12}

Map literals are like struct literals, but the
keys are required
 var myMap = map [string] Vertex{
“Red”: Vertex {12, 12},
“Yellow”: Vertex {12, 66},
}
Alternatively, if the top-level type is just a
type name, you can omit it from the
elements of the literal


var myMap = map [string] Vertex{
“Red”: {12,12}
“Yellow”: {12,66}
}
Arrays
Arrays are structures that store one or
more values linearly
 Its values are accessed by integer indices
from 0 to len(arrayName) – 1
 The len(arrayName) function is built in and
returns the length of the passed in array
 Syntax:

myArray := [5] int {1,2,3,4,5};

The size of an array is included as part of
its type. So [2] int is a different type than
[5]int.

Arrays in Go are different from arrays in C
 Arrays are values. Assigning one array to
another copies all its elements.
 Passing an array to a function sends a copy of
the array, not a pointer to it (unless otherwise
specified).
 The size of an array is part of its type.
 Go does not support the pointer arithmetic tricks
that you might use in C. Instead, when you
make a pointer to an array, you get a pointer to
the actual array, not just a pointer to something
that happens to be the first thing in the array.

Arrays are one dimensional but can be
composed to make multiple dimensions
(an array of arrays)
 [5] [15] int is equivalent to [5] ([15] int)

Syntax:
 array2D := [2] ([3] int) { {1,2,3}, {4,5,6} }
//an array with two elements, each element
//being an array with 3 elements
Slices
A slice points to an array of values
 It also has a built-in length
 Syntax:

 aSlice := []int {1,2,3}

A slice can be cut from an array
 arrayName := [5] int {1,2,3,4,5}
arraySlice := arrayName[a:b]
The size of a slice is b-a
 arrayName[a:a] includes no elements
 arrayName[a:a+1] includes one element






Slices are abstractions of arrays
Slices are more flexible than arrays and as
a result are more common in Go code
Slices have no specified lengths like arrays
do
Slices can be grown with the built-in copy
or append function
The keyword range allows you to loop
through an entire slice or array


Slices are also created with make
Syntax:
 arraySlice := make([]int, 5)



This allocates an array of length 5 and returns
a slice that refers to the array
All the values are initialized to 0
The make function can also be passed a third
parameter to specify the capacity of the slice
 arraySlice := make([]int, 5, 10)
 Here, the length is 5, but the slice can grow up to 10
Tying it all together

An application: creating a simple
address book

addressBook.go maps values in a slice
of strings to values in a slice of ints

addressBook2.go uses structs to
achieve something similar