Learn to use Arrays and Slices in the Go language!

Arrays and Slices

So far we've been using arrays, which have a fixed size. If we were to want to store a different number of elements in our array, we'd have to make a whole new one. However, Go provides us with a useful alternative.

**Slices** are a data collection type similar to arrays, but they have the ability to change their size. We will cover how to do that in later exercises, but first we will learn how to make a slice in the first place.

There are multiple ways to create a slice. We can create a slice from an array, or by itself. Let's start with creating a slice by itself.

```go
// Each of the following creates an empty slice
var numberSlice []int
stringSlice := []string{}

// The following creates a slice with elements
names := []string{"Kathryn", "Martin", "Sasha", "Steven"}
```

While this last slice currently has four elements, we would be able to continue to add elements using functions covered in later exercises.

We can also take an array, and create a slice based on that array. Modifying the slice will still update the original array.

```go
array := [5]int{2, 5, 7, 1, 3}
// This is a slice of the whole array
sliceVersion := array[:]
fmt.Println(sliceVersion)
// [2 5 7 1 3]
// This is a slice containing the elements at indices 2, 3, and 4
partialSlice := array[2:5]
fmt.Println(partialSlice)
// [7 1 3]
```

One of the best parts about slices is that their elements are accessed and modified the same way as arrays! Since we already know how to do this with arrays, we also know slices

```go
var names = []string{"Kathryn", "Martin", "Sasha", "Steven"}
fmt.Println(names[1])
// Martin
names[3] = "Bishop"
fmt.Println(names[3])
// Bishop
```

Let's practice using some slices in our programs.

Introduction to Slices

We've learned how to create arrays that contain values. But how can we access the values stored in arrays?

While having a list of numbers in a program might look nice, we need to access values to do useful computation. We need to use or modify individual values to perform activities such as:

- finding the sum of all the elements (or some other value)
- updating a value for a particular element
- searching for a particular value within the array

Without being able to access or change values, an array is only a pretty list!
To access elements of an array, we use something called **indexing**. As mentioned before, each element of an array has an index.

One thing that often confuses new programmers is the index at the start of the array. Go uses `0` as the first index of the array, meaning that it stores the first element at **index 0**. It might be tempting to try and access the first element with index 1, but this will access the second element.

Let's take a look at accessing an array of student names, defined here:

```go
students = [3]string{"Jill", "Fred", "Sasha"}
// Access the first element of the array
fmt.Println(students[0])
// Output: Jill
// Access the third element of the array
fmt.Println(students[2])
// Output: Sasha
// Store the second element into a variable
secondStudent := students[1]
// Print it
fmt.Println(secondStudent)
// Output: Fred
```

Accessing array elements is helpful, but we often need to change values stored in our array. Modifying array values will be the subject of our next exercise.

First, let's practice accessing elements for use in our computations.

Access Array Values with Indices

All of this array and slice functionality is useful, but we need to be able to use it outside of `main`. In this exercise, we will learn to define functions which allow us to repeat functionality using arrays or slices.

We can pass arrays or slices into functions as parameters. To pass an array parameter into a function, we provide a local name, square brackets, and the data type. The difference between slice and array parameters is whether the number of elements is stated:

```go
func printFirstLastArray(array [4]int) {
    fmt.Println("First", array[0])
    fmt.Println("Last", array[3])
}

func printFirstLastSlice(slice []int) {
    length := len(slice)
    if (length > 0) {
        fmt.Println("First", slice[0])
        fmt.Println("Last", slice[length-1])
    }
}
```

Due to Go being a pass by value language, modifying a normal array parameter won't create permanent change. Sometimes this can be useful in performing local calculations.

```go
// Changes to the array will only be local to the function
func changeFirst(array [4]int, value int) {
    array[0] = value
}
```

In order to retain changes, a slice can be used:

```go
// Changes to the slice parameter will be permanent
func changeFirst(slice []int, value int) {
    if (len(slice) > 0) {
        slice[0] = value
    }
}
```

Let's practice using arrays in our functions!

Arrays and Slices in Functions

While empty arrays are useful, so are arrays already populated with elements! Sometimes we already know which values we are going to put in our array.

Imagine we are doing some math homework, and using the same triangles over an over again. We could declare two arrays with the values of the side lengths and angles for that triangle.

```go
triangleSides := [3]int{15, 26, 30}
triangleAngles := [...]int{30, 60, 90}
```

Notice how the syntax between these two lines is different. When creating an array with values, we can have the compiler determine the length automatically using `...` ellipsis syntax.

So now we have some values, but how can we use these to do our math homework? In the next exercise, we will learn how to access the values stored in our arrays.

Before that, let's create some arrays populated with values.

Array Creation with Elements

So far we have covered what arrays and slices are, and how to work with them at a basic level. However, a big aspect of working with slices are that we can add elements and the slice will resize automatically. But how do we add to a slice?

Go provides us with a function, `append` that handles all of the logic of adding to and resizing a slice:

```go
books := []string{"Tom Sawyer", "Of Mice and Men"}
books = append(books, "Frankenstein")
books = append(books, "Dracula")
fmt.Println(books)
// [Tom Sawyer Of Mice and Men Frankenstein Dracula]
```

Being able to add new elements to a slice is very important. Especially when data comes in over time that we cannot predict.

Let's practice appending elements in a Go program!

Append to Slices

To use arrays in our programs, we must first declare and name them. In Go, there are a variety of ways in which we can declare an array. In the next few exercises, we will explore methods of array creation.

When we declare a variable in Go, the compiler:

- Finds space in memory for that variable
- Associates the variable with a name

Using arrays makes the compiler's job a little more complicated. When we declare a single variable, the compiler needs to find enough space for one of that data type. When we declare an array, the compiler is going to have to find enough space for several of a data type.

To make this process simple, declaring an array in Go requires that we provide the number of elements. Once declared, we cannot change this number without declaring a new array. The compiler finds enough space for the array's type, multiplied by the number of elements.

We can create arrays with or without an initial set of elements. We use an array without initial elements when the rest of our program will create the array's content. To create an array without an initial set of elements we use the following syntax:

```go
var playerScores [4]int
fmt.Println(playerScores)
// [0 0 0 0]
```

This syntax creates an empty array of integer values with space for 4 elements. We could create an array like this and later fill it with values from user input.

While empty arrays are great for storing data we can't predict, sometimes we already know what we want in our array! In the next exercise, we'll introduce a way to create an array filled with particular values.

First, let's practice creating an empty array.

Array Creation

Why might we need to find the length of an array? Describe a scenario or scenarios in which this would be useful.

### len

`len` is a function which returns the length of an array or slice passed into it:

```go
favoriteThings := [2]string{"Raindrops on Roses", "Whiskers on Kittens"}
fmt.Println(len(favoriteThings))
// 2

fmt.Println(len(nastyThings))
// 3
```

`len` is used when working with loops, as well as validating whether an index can be used on an array or slice. Accessing an element beyond the length results in an error.

Arrays only have a length, but when it comes to slices, there is an additional element to consider, capacity.

### Capacity

A slice is resizeable, so there is a difference between:

- Its length, the current number of elements it holds
- Its **capacity**, the number of elements it can hold before needing to resize itself.

A slice's capacity can be accessed through the `cap` function:

```go
slice := []string{"Fido", "Fifi", "FruFru"}
// The slice begins at length 3 and capacity 3
fmt.Println(slice, len(slice), cap(slice))
// [Fido Fifi FruFru] 3 3
slice = append(slice, "FroFro")
// After appending an element when the slice is at capacity
// The slice will double in capacity, but increase its length by 1
fmt.Println(slice, len(slice), cap(slice))
// [Fido Fifi FruFru FroFro] 4 6
```

Note how in the above example, when we added an element to a slice which was at full capacity the following occured:

- The new element was still able to be added
- The length increased to fit the new element
- The capacity doubled in size.

All of this happens automatically using slices, while this is not possible with arrays!

Length and Capacity

Being able to retrieve the values stored in our array is super helpful, but what if we need to change them? Changing an array value is something that happens all the time in professional programs. Consider:

- Counting or calculating a value over time
- Recieving new information about a piece of data
- Having data change positions within the array

All of these scenarios require that we change the value initially stored in our array. The syntax for doing so is quite simple

```go
array[index] = value
```

Where index is any valid index in the array, `value` is any expression we want. Let's say we had an array:

```go
myArray := [4]int{10, 24, 5, 47}
```

Let's say that we decide we want the third element to now be `33`. We could change the array at that index with the following line:

```go
myArray[2] = 33
```

The content of the array would now be `{10, 24, 33, 47}`

We can use this syntax to modify any valid index, between `0` and the length of the array.

In the next exercise, we will learn about slices, which allow us to add additional length to our lists, but for now, let's practice modifying elements!

Modifying Array Values

Imagine we are creating an online gaming platform, and need to keep track of players' scores. For each player, we'd need to store their score at a consistent index for that player. This is a situation in which arrays would come in handy!

An **array** is a collection of data elements of the same type, where we can access each **element** by an **index**. We can think of an array as a row of mailboxes, with each index representing a house number.

```
[0][1][2][3][4][5]
```

Arrays are one of the most common forms of variables used in programs. We use arrays for tasks such as:

- Storing many pieces of input
- Storing related collections of values
- Performing mathematical operations on lists of numbers

Across the world, arrays are being used in billions of running programs!

Throughout this course, we will introduce and practice using arrays in our programs. Over the next several exercises we will introduce:

- Creating arrays
- Accessing array values
- Using the length of an array

To begin using arrays in our programs, we will first have to create them. We will get started creating arrays in the next exercise.


Introduction to Arrays

Throughout this exercise, we have introduced concepts and syntax related to using arrays and slices in our Go programs. Let's take a moment to review what we've learned.

An array is a fixed size ordered list of elements with the same data type. Arrays are useful for collecting and accessing multiple related values. Example use cases include:

    - Storing sensor values
    - Computing averages
    - Holding lists of information

Both arrays and slices are collections of multiple elements of the same data type. However, a slice can be resized to hold additional elements, whereas an array cannot.

An array's capacity is its length, and this cannot change. A slice has both a length and a capacity, where:

- The slice's length is the current number of elements it holds
- The slice's capacity is the number of elements it can hold before needing to resize itself.

#### Array Creation

There are a variety of ways to create arrays:

An empty array can be created by specifying its number of intended elements and its type.

```go
var myArray [3]int
```

An array can be created with elements in two ways:

Specifying:

- The number of elements
- The type
- A list of values

```go
animals := [4]string{"Dog", "Hippo", "Cat", "Hamster"}
```

Or using the `...` syntax to automatically determine the number of elements:

```go
animals := [...]string{"Dog", "Hippo", "Cat", "Hamster"}
```

#### Slice Creation

A slice can be created with or without elements.

Without elements, an empty set of square brackets `[]` and the data type is provided:

```go
var numberSlice []int
```

With elements, a list of items enclosed in curly braces `{}` is also provided:

```go
names := []string{"Kathryn", "Martin", "Sasha", "Steven"}
```

#### Array and Slice Access and Modification

Values within an array or slice can be accessed using a square bracket `[]` syntax:

```go
value := array[index]
```

Values can be modified using square brackets `[]`, an index, and the assignment operator `=`:

```go
array[index] = value
```

#### Array and Slice Functions

The length of an array or slice can be accessed using the `len` function.

```go
length := len(sliceOrArray)
```

The capacity of a slice can be accessed using the `cap` function.

```
capacity := cap(slice)
```

An element can be added to the end of a slice using the `append` function:

```go
slice := append(slice, newElement)
```

#### Conclusion

We can use all of this knowledge to collect and modify data values in our programs. Try out a variety of arrays and slices as you create more complex Go programs!