GO LANGUAGE DATA STRUCTURES

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 structred := Vertex{12,12} // X and Y equal 12

You can use the variableName: to specify a particular valueyellow := Vertex{Y: 66, X: 12}

//Y equals 66, X equals 12, order does not matter

Or you can implicitly assign valuesblue := 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] Vertexfunc 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 requiredvar 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 CArrays 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 slicearraySlice := 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