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.

var myArray [3]int

An array can be created with elements in two ways:


  • The number of elements
  • The type
  • A list of values
animals := [4]string{"Dog", "Hippo", "Cat", "Hamster"}

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

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:

var numberSlice []int

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

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:

value := array[index]

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

array[index] = value

Array and Slice Functions

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

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:

slice := append(slice, newElement)


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!


Take a look at the workspace for this exercise. It reviews many of the concepts we’ve learned in this lesson. You aren’t required to do anything, but we suggest:

  • Modify the array’s content
  • Create new arrays
  • Add content to slices
  • Determine the length of additional arrays
  • Change the functions to use strings instead of numbers
  • Can you change the functions to both use slices?

Take this course for free

Mini Info Outline Icon
By signing up for Codecademy, you agree to Codecademy's Terms of Service & Privacy Policy.

Or sign up using:

Already have an account?