Arrays and slices are two important data structures in Go used to store multiple values of the same type.

At first, arrays and slices may look very similar, but they behave differently.

An array has a fixed length.

A slice is more flexible and can grow or shrink as needed.

In real Go applications, slices are used much more frequently than arrays, but understanding arrays first makes slices much easier to learn.

In this beginner’s guide, you will learn how arrays and slices work, how to create them, access values, update elements, loop through them, use append(), understand length and capacity, copy slices, and avoid common mistakes.

What Is an Array in Go?

An array stores a fixed number of values of the same type.

Example:

var numbers [3]int

This creates an array that can store exactly three integers.

The length:

is part of the array type.

So:

[3]int

and:

[5]int

are different array types in Go.

Creating an Array

You can declare an array without assigning values:

var numbers [3]int

Because no values were provided, Go fills the array with zero values.

Example:

package main

import "fmt"

func main() {
    var numbers [3]int

    fmt.Println(numbers)
}

Output:

[0 0 0]

For an int array, the zero value is 0.

Initialize an Array with Values

You can provide values when creating the array.

Example:

numbers := [3]int{10, 20, 30}

Print it:

fmt.Println(numbers)

Output:

[10 20 30]

Let Go Determine the Array Length

You can use:

...

to let Go calculate the length automatically.

Example:

numbers := [...]int{10, 20, 30, 40}

Go understands that the array length is:

You can check:

fmt.Println(len(numbers))

Output:

Access Array Elements

Array elements are accessed using indexes.

Example:

numbers := [3]int{10, 20, 30}

Access the first value:

fmt.Println(numbers[0])

Output:

Access the second:

fmt.Println(numbers[1])

Output:

Array indexes start at:

So for:

[10 20 30]

the indexes are:

Index 0 → 10
Index 1 → 20
Index 2 → 30

Update an Array Element

You can change an element using its index.

Example:

numbers := [3]int{10, 20, 30}

numbers[1] = 50

Print:

fmt.Println(numbers)

Output:

[10 50 30]

Array Length

Use the built-in:

len()

function.

Example:

numbers := [4]int{10, 20, 30, 40}

fmt.Println(len(numbers))

Output:

The length of an array cannot change after creation.

Different Array Types

Arrays can store many different Go types.

String array:

names := [3]string{"John", "Alex", "Sam"}

Boolean array:

values := [3]bool{true, false, true}

Float array:

prices := [3]float64{10.5, 20.99, 50.25}

However, all elements in one array must have the same element type.

Loop Through an Array

You can use a regular for loop.

Example:

numbers := [3]int{10, 20, 30}

for i := 0; i < len(numbers); i++ {
    fmt.Println(numbers[i])
}

Output:

10
20
30

Loop Through an Array with range

Go provides the range keyword.

Example:

numbers := [3]int{10, 20, 30}

for index, value := range numbers {
    fmt.Println(index, value)
}

Output:

0 10
1 20
2 30

Ignore the Index

If you only need the values:

for _, value := range numbers {
    fmt.Println(value)
}

The underscore:

is the blank identifier.

It tells Go that you intentionally do not need the index.

Ignore the Value

If you only need indexes:

for index := range numbers {
    fmt.Println(index)
}

Output:

0
1
2

Arrays Are Fixed in Size

This is one of the most important array rules.

Suppose you create:

numbers := [3]int{10, 20, 30}

You cannot simply add a fourth element to the same array.

The array always has exactly three positions.

This fixed-size behavior is one major reason slices are more commonly used in Go applications.

What Is a Slice in Go?

A slice is a flexible view over an underlying array.

For beginners, the simplest way to think about a slice is:

A slice works like a dynamically sized collection of values of the same type.

Example:

numbers := []int{10, 20, 30}

Notice the difference.

Array:

[3]int{10, 20, 30}

Slice:

[]int{10, 20, 30}

A slice does not specify a fixed length inside the brackets.

Creating a Slice

The easiest way is:

numbers := []int{10, 20, 30}

Example:

package main

import "fmt"

func main() {
    numbers := []int{10, 20, 30}

    fmt.Println(numbers)
}

Output:

[10 20 30]

Create an Empty Slice

You can create an empty slice:

var numbers []int

Example:

package main

import "fmt"

func main() {
    var numbers []int

    fmt.Println(numbers)
    fmt.Println(len(numbers))
}

The length will be:

Nil Slice

A slice declared like this:

var numbers []int

is a nil slice.

You can check:

fmt.Println(numbers == nil)

Output:

true

A nil slice has:

Length = 0
Capacity = 0

You can still use append() with it.

Example:

numbers = append(numbers, 10)

Create a Slice Using make()

Go provides:

make()

for creating slices.

Example:

numbers := make([]int, 3)

This creates a slice with length:

and zero values.

Print:

fmt.Println(numbers)

Output:

[0 0 0]

make() with Length and Capacity

You can also specify capacity.

Example:

numbers := make([]int, 3, 5)

Here:

Length   = 3
Capacity = 5

Check them:

fmt.Println(len(numbers))
fmt.Println(cap(numbers))

Output:

3
5

Access Slice Elements

Slices use indexes just like arrays.

Example:

numbers := []int{10, 20, 30}

fmt.Println(numbers[0])

Output:

Update Slice Elements

Example:

numbers := []int{10, 20, 30}

numbers[1] = 100

Print:

fmt.Println(numbers)

Output:

[10 100 30]

Slice Length

Use:

len()

Example:

numbers := []int{10, 20, 30}

fmt.Println(len(numbers))

Output:

Slice Capacity

Slices also have a capacity.

Use:

cap()

Example:

numbers := make([]int, 3, 5)

fmt.Println(len(numbers))
fmt.Println(cap(numbers))

Output:

3
5

Length vs Capacity

This is an important concept.

Length means how many elements are currently available in the slice.

Capacity means how many elements the slice can contain using its current underlying storage before Go may need to allocate new storage.

Example:

numbers := make([]int, 3, 5)

Here:

Length   = 3
Capacity = 5

Add Elements with append()

One of the biggest advantages of slices is the ability to add elements.

Use:

append()

Example:

numbers := []int{10, 20, 30}

numbers = append(numbers, 40)

Print:

fmt.Println(numbers)

Output:

[10 20 30 40]

Append Multiple Elements

You can add multiple values at once.

Example:

numbers := []int{10, 20}

numbers = append(numbers, 30, 40, 50)

Output:

[10 20 30 40 50]

Why Do We Assign append() Back?

You commonly see:

numbers = append(numbers, 40)

rather than:

append(numbers, 40)

This is because append() returns the resulting slice.

The returned slice may refer to different underlying storage if additional capacity was required.

So you should normally keep the returned value.

Append One Slice to Another

Suppose:

a := []int{10, 20}
b := []int{30, 40}

You can append b to a:

a = append(a, b...)

Print:

fmt.Println(a)

Output:

[10 20 30 40]

The:

...

expands the second slice into individual values.

Create a Slice from an Array

You can create a slice from part of an array.

Example:

numbers := [5]int{10, 20, 30, 40, 50}

Create a slice:

part := numbers[1:4]

Print:

fmt.Println(part)

Output:

[20 30 40]

Understanding Slice Syntax

The syntax:

numbers[start:end]

includes:

start

but does not include:

end

For:

numbers[1:4]

Go takes indexes:

1
2
3

but not index:

Slice from the Beginning

Example:

numbers := []int{10, 20, 30, 40, 50}

part := numbers[:3]

Output:

[10 20 30]

Slice to the End

Example:

part := numbers[2:]

Output:

[30 40 50]

Copy a Slice

Go provides:

copy()

to copy elements between slices.

Example:

source := []int{10, 20, 30}

destination := make([]int, len(source))

copy(destination, source)

Print:

fmt.Println(destination)

Output:

[10 20 30]

Why Use copy()?

Slices may share underlying arrays.

Sometimes you want an independent copy.

Example:

original := []int{10, 20, 30}

copied := make([]int, len(original))
copy(copied, original)

copied[0] = 100

Now:

fmt.Println(original)
fmt.Println(copied)

Output:

[10 20 30]
[100 20 30]

The copied slice can be changed without changing the original values in this example.

Slices Can Share Underlying Data

Consider:

numbers := []int{10, 20, 30, 40}

part := numbers[1:3]

Now:

part[0] = 100

Print both:

fmt.Println(part)
fmt.Println(numbers)

Output:

[100 30]
[10 100 30 40]

Why?

Because part is viewing the same underlying array as numbers.

This is an important slice behavior to understand.

Loop Through a Slice

Use range:

numbers := []int{10, 20, 30}

for index, value := range numbers {
    fmt.Println(index, value)
}

Output:

0 10
1 20
2 30

Loop Through Values Only

for _, value := range numbers {
    fmt.Println(value)
}

Output:

10
20
30

Regular for Loop with Slice

You can also write:

for i := 0; i < len(numbers); i++ {
    fmt.Println(numbers[i])
}

Both approaches are valid.

Find the Sum of Slice Elements

Example:

package main

import "fmt"

func main() {
    numbers := []int{10, 20, 30, 40}

    total := 0

    for _, number := range numbers {
        total += number
    }

    fmt.Println("Total:", total)
}

Output:

Total: 100

Find the Largest Value

Example:

numbers := []int{10, 50, 20, 80, 30}

largest := numbers[0]

for _, number := range numbers {
    if number > largest {
        largest = number
    }
}

fmt.Println(largest)

Output:

For this example, make sure the slice is not empty before accessing:

numbers[0]

Check Whether a Slice Is Empty

Use:

len(numbers) == 0

Example:

if len(numbers) == 0 {
    fmt.Println("Slice is empty")
}

This works for both nil and non-nil empty slices.

Removing an Element from a Slice

Go does not have a built-in remove() function for slices.

Suppose:

numbers := []int{10, 20, 30, 40}

To remove the item at index 1:

index := 1

numbers = append(numbers[:index], numbers[index+1:]...)

Output:

[10 30 40]

This is a common beginner technique.

Remove the Last Element

Example:

numbers := []int{10, 20, 30, 40}

numbers = numbers[:len(numbers)-1]

Output:

[10 20 30]

Make sure the slice is not empty before doing this.

Remove the First Element

Example:

numbers := []int{10, 20, 30}

numbers = numbers[1:]

Output:

[20 30]

Insert an Element into a Slice

Suppose:

numbers := []int{10, 20, 40}

You want to insert 30 at index 2.

One simple approach is:

numbers = append(numbers, 0)

copy(numbers[3:], numbers[2:])

numbers[2] = 30

Result:

[10 20 30 40]

For beginners, it is enough to understand that insertion requires shifting existing elements because slices do not provide a dedicated insert method.

Array vs Slice in Go

Arrays and slices have several important differences.

Feature	Array	Slice
Size	Fixed	Flexible
Length in type	Yes	No
Can use append()	No	Yes
Common in normal Go code	Less common	Very common
Can be sliced	Yes	Yes
Has capacity concept	Not used like slices	Yes
Easy to grow	No	Yes

Example array:

numbers := [3]int{10, 20, 30}

Example slice:

numbers := []int{10, 20, 30}

The small difference in syntax changes how the collection behaves.

Arrays Are Values

Arrays in Go behave as values.

For example:

a := [3]int{10, 20, 30}

b := a

b[0] = 100

Print:

fmt.Println(a)
fmt.Println(b)

Output:

[10 20 30]
[100 20 30]

Changing b does not change a.

The array was copied.

Slices Behave Differently

Slices contain information describing a section of an underlying array.

Example:

a := []int{10, 20, 30}

b := a

b[0] = 100

Print:

fmt.Println(a)
fmt.Println(b)

You will see that the change is visible through both slices because they refer to the same underlying data.

This is one of the major behavioral differences between arrays and slices.

Passing an Array to a Function

Example:

func change(numbers [3]int) {
    numbers[0] = 100
}

Usage:

numbers := [3]int{10, 20, 30}

change(numbers)

fmt.Println(numbers)

The original array remains unchanged because the array value is copied when passed to the function.

Passing a Slice to a Function

Slices are commonly passed to functions.

Example:

func change(numbers []int) {
    numbers[0] = 100
}

Usage:

numbers := []int{10, 20, 30}

change(numbers)

fmt.Println(numbers)

Output:

[100 20 30]

The function can modify elements of the underlying data.

Return a Slice from a Function

Example:

func getNumbers() []int {
    return []int{10, 20, 30}
}

Usage:

numbers := getNumbers()

fmt.Println(numbers)

Output:

[10 20 30]

Returning slices is very common in Go.

Slice of Strings

Example:

names := []string{"John", "Alex", "Sam"}

Loop:

for _, name := range names {
    fmt.Println(name)
}

Output:

John
Alex
Sam

Slice of Booleans

Example:

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

Print:

fmt.Println(values)

Output:

[true false true]

Slice of Structs

Slices can also store custom types.

Example:

type User struct {
    Name string
    Age  int
}

Create a slice:

users := []User{
    {Name: "John", Age: 25},
    {Name: "Alex", Age: 30},
}

Loop:

for _, user := range users {
    fmt.Println(user.Name, user.Age)
}

Output:

John 25
Alex 30

This pattern is extremely common in real applications.

Multidimensional Arrays

Go supports arrays containing arrays.

Example:

matrix := [2][3]int{
    {1, 2, 3},
    {4, 5, 6},
}

Print:

fmt.Println(matrix)

Output:

[[1 2 3] [4 5 6]]

Multidimensional Slices

You can also create slices of slices.

Example:

matrix := [][]int{
    {1, 2, 3},
    {4, 5, 6},
}

Access:

fmt.Println(matrix[0][1])

Output:

Common Array and Slice Errors

Index Out of Range

Suppose:

numbers := []int{10, 20, 30}

Valid indexes are:

0
1
2

This is invalid:

fmt.Println(numbers[3])

It can cause a runtime panic because index 3 does not exist.

Always make sure:

index < len(numbers)

Using append() Without Saving the Result

Avoid:

append(numbers, 40)

Prefer:

numbers = append(numbers, 40)

Because append() returns the resulting slice.

Confusing Array and Slice Syntax

Array:

[3]int{10, 20, 30}

Slice:

[]int{10, 20, 30}

The number inside the brackets means you are creating an array of that length.

Accessing an Empty Slice

This is unsafe:

var numbers []int

fmt.Println(numbers[0])

The slice has no elements.

Check first:

if len(numbers) > 0 {
    fmt.Println(numbers[0])
}

Confusing Length and Capacity

Suppose:

numbers := make([]int, 2, 5)

You cannot directly access:

numbers[4]

just because capacity is 5.

The current length is only:

Valid indexes are currently:

0
1

Capacity does not automatically mean those elements are part of the current slice length.

Best Practices for Arrays and Slices

Use slices for most collections whose size may change.

Use arrays when a fixed-size collection is specifically useful.

Check slice length before accessing uncertain indexes.

Store the result of append().

Use range when iterating through elements.

Use meaningful variable names.

Be careful when multiple slices share the same underlying data.

Use copy() when you need an independent copy of slice elements.

Avoid unnecessary preallocation unless you know approximately how much data you will store.

When the expected size is known, creating capacity in advance can sometimes reduce repeated allocations.

Example:

users := make([]string, 0, 100)

Practical Example: Student Scores

Here is a simple practical example using a slice.

package main

import "fmt"

func main() {
    scores := []int{80, 90, 70, 85, 95}

    total := 0

    for _, score := range scores {
        total += score
    }

    average := float64(total) / float64(len(scores))

    fmt.Println("Scores:", scores)
    fmt.Println("Total:", total)
    fmt.Println("Average:", average)
}

Output:

Scores: [80 90 70 85 95]
Total: 420
Average: 84

Practical Example: Add Products

package main

import "fmt"

func main() {
    products := []string{"Laptop", "Phone"}

    products = append(products, "Tablet")
    products = append(products, "Watch")

    for index, product := range products {
        fmt.Println(index, product)
    }
}

Output:

0 Laptop
1 Phone
2 Tablet
3 Watch

This demonstrates why slices are convenient for collections that can grow.

Go Arrays and Slices Quick Reference

Create array:

numbers := [3]int{10, 20, 30}

Automatic array length:

numbers := [...]int{10, 20, 30}

Create slice:

numbers := []int{10, 20, 30}

Create empty slice:

var numbers []int

Create slice with make():

numbers := make([]int, 3)

Length:

len(numbers)

Capacity:

cap(numbers)

Append:

numbers = append(numbers, 40)

Slice part of a collection:

part := numbers[1:3]

Copy:

copy(destination, source)

Loop:

for _, value := range numbers {
    fmt.Println(value)
}

Frequently Asked Questions

What is an array in Go?

An array is a fixed-length collection of elements of the same type.

What is a slice in Go?

A slice is a flexible data structure representing a sequence of elements over an underlying array.

What is the main difference between an array and a slice?

Arrays have a fixed length, while slices are flexible and can grow using append().

Which is used more often in Go?

Slices are used much more commonly in everyday Go applications because they are more flexible.

How do I add an element to a slice?

Use:

slice = append(slice, value)

Can I add elements to an array?

No. An array has a fixed length once created.

How do I check the length of a slice?

Use:

len(slice)

How do I check slice capacity?

Use:

cap(slice)

What does make() do for slices?

make() creates and initializes a slice with a specified length and optional capacity.

Example:

make([]int, 3, 5)

What is a nil slice?

A nil slice is a slice with no underlying allocated slice storage yet and has length and capacity of zero.

Example:

var numbers []int

Can slices share data?

Yes. Multiple slices can refer to the same underlying array, so changes through one slice may be visible through another.

How do I create an independent slice copy?

Create another slice and use copy().

Example:

copied := make([]int, len(original))

copy(copied, original)

Can a slice store structs?

Yes. Slices can store any appropriate Go type, including structs.

Example:

[]User

Conclusion

Arrays and slices are essential data structures in Go.

An array has a fixed size:

numbers := [3]int{10, 20, 30}

A slice has a flexible length:

numbers := []int{10, 20, 30}

For beginners, the most important slice operations to understand are:

Create
Access
Update
Loop
Append
Slice
Copy
Check length
Check capacity

You should also remember that slices can share an underlying array, which means changing one slice may sometimes affect another.

In most real Go programs, you will use slices more frequently because they are easier to work with when the number of elements can change.

Once you understand arrays and slices, the next useful Go collection to learn is the map, which stores data using key-value pairs.

Go Arrays and Slices Explained

What Is an Array in Go?

Creating an Array

Initialize an Array with Values

Let Go Determine the Array Length

Access Array Elements

Update an Array Element

Array Length

Different Array Types

Loop Through an Array

Loop Through an Array with range

Ignore the Index

Ignore the Value

Arrays Are Fixed in Size

What Is a Slice in Go?

Creating a Slice

Create an Empty Slice

Nil Slice

Create a Slice Using make()

make() with Length and Capacity

Access Slice Elements

Update Slice Elements

Slice Length

Slice Capacity

Length vs Capacity

Add Elements with append()

Append Multiple Elements

Why Do We Assign append() Back?

Append One Slice to Another

Create a Slice from an Array

Understanding Slice Syntax

Slice from the Beginning

Slice to the End

Copy a Slice

Why Use copy()?

Slices Can Share Underlying Data

Loop Through a Slice

Loop Through Values Only

Regular for Loop with Slice

Find the Sum of Slice Elements

Find the Largest Value

Check Whether a Slice Is Empty

Removing an Element from a Slice

Remove the Last Element

Remove the First Element

Insert an Element into a Slice

Array vs Slice in Go

Arrays Are Values

Slices Behave Differently

Passing an Array to a Function

Passing a Slice to a Function

Return a Slice from a Function

Slice of Strings

Slice of Booleans

Slice of Structs

Multidimensional Arrays

Multidimensional Slices

Common Array and Slice Errors

Index Out of Range

Using append() Without Saving the Result

Confusing Array and Slice Syntax

Accessing an Empty Slice

Confusing Length and Capacity

Best Practices for Arrays and Slices

Practical Example: Student Scores

Practical Example: Add Products

Go Arrays and Slices Quick Reference

Frequently Asked Questions

What is an array in Go?

What is a slice in Go?

What is the main difference between an array and a slice?

Which is used more often in Go?

How do I add an element to a slice?

Can I add elements to an array?

How do I check the length of a slice?

How do I check slice capacity?

What does make() do for slices?

What is a nil slice?

Can slices share data?

How do I create an independent slice copy?