Stage 1 · Code

Functions & Composite Types

Arrays & Slices

Understand Go's two sequence types: fixed-size arrays and the dynamic slices that make everyday list work fast and safe.

8 min readProgramming Foundations (Go)Code

Arrays

Array layout in memory

95[0]

100[4]

An array is a fixed-length sequence of elements of the same type. The length is part of the type: [3]int and [5]int are different types. Arrays are passed by value — a function receives its own copy.

Godeclaring-and-using-arrays.go

22 linesLn 1, Col 1Go

`[...]` tells Go to count the elements and set the length automatically. You cannot resize an array after declaration — that is what slices are for.

Arrays are rarely used directly in Go

In most Go code you will work with slices, not arrays. Arrays are the underlying storage mechanism that slices sit on top of. Knowing arrays helps you understand what slices are doing under the hood.

Slices

A slice is a descriptor with three fields: a pointer to an underlying array, a length, and a capacity. Slices are reference types — multiple slices can share the same underlying array.

Gocreating-slices.go

22 linesLn 1, Col 1Go

`make([]T, len, cap)` is the standard way to pre-allocate a slice when you know the expected size. Pre-allocating avoids repeated allocations as the slice grows.

append, len, cap

append adds elements to a slice and returns the new slice. When the underlying array has no room, append allocates a larger array and copies the data. Always capture the returned slice.

Gogrowing-slices-with-append.go

19 linesLn 1, Col 1Go

Go doubles capacity (approximately) when a slice needs to grow. The current capacity is visible with `cap()`. You cannot rely on a specific capacity value — treat it as an implementation detail.

Always reassign the result of append

append may or may not return the same slice header depending on whether reallocation happened. If you call append(s, x) without capturing the result into s, you silently discard the new element. Always write s = append(s, x).

Slicing Expressions

A slicing expression s[low:high] produces a new slice that shares the same underlying array as s. Modifying elements through one slice affects the other.

Goslicing-and-shared-memory.go

23 linesLn 1, Col 1Go

Slice expressions create views into existing data — no copying happens. This is efficient but requires care: mutating a sub-slice also mutates the original. Use `copy` or the full three-index form to isolate slices.

copy

copy(dst, src) copies elements from src into dst and returns the number of elements copied (the minimum of the two lengths). After copying, dst and src are independent — changes to one do not affect the other.

Gocopying-slices-safely.go

24 linesLn 1, Col 1Go

Always `make` the destination slice with the right length before calling `copy`. `copy` does not extend the destination — it only fills up to `len(dst)` elements.

Operation	Creates new array?	Independent?
Slice expression `s[a:b]`	No	No — shares underlying array
`copy(dst, src)`	No (dst must already exist)	Yes — independent after copy
`append` beyond capacity	Yes	Yes — new backing array allocated

Mark this lesson complete to store local progress and unlock a cleaner resume path the next time you visit.

Stage 1 · Code

Functions & Composite Types

Arrays & Slices

Understand Go's two sequence types: fixed-size arrays and the dynamic slices that make everyday list work fast and safe.

8 min readProgramming Foundations (Go)Code

Arrays

Array layout in memory

95[0]

100[4]

Godeclaring-and-using-arrays.go

22 linesLn 1, Col 1Go

`[...]` tells Go to count the elements and set the length automatically. You cannot resize an array after declaration — that is what slices are for.

Arrays are rarely used directly in Go

In most Go code you will work with slices, not arrays. Arrays are the underlying storage mechanism that slices sit on top of. Knowing arrays helps you understand what slices are doing under the hood.

Slices

A slice is a descriptor with three fields: a pointer to an underlying array, a length, and a capacity. Slices are reference types — multiple slices can share the same underlying array.

Gocreating-slices.go

22 linesLn 1, Col 1Go

`make([]T, len, cap)` is the standard way to pre-allocate a slice when you know the expected size. Pre-allocating avoids repeated allocations as the slice grows.

append, len, cap

append adds elements to a slice and returns the new slice. When the underlying array has no room, append allocates a larger array and copies the data. Always capture the returned slice.

Gogrowing-slices-with-append.go

19 linesLn 1, Col 1Go

Go doubles capacity (approximately) when a slice needs to grow. The current capacity is visible with `cap()`. You cannot rely on a specific capacity value — treat it as an implementation detail.

Always reassign the result of append

Slicing Expressions

A slicing expression s[low:high] produces a new slice that shares the same underlying array as s. Modifying elements through one slice affects the other.

Goslicing-and-shared-memory.go

23 linesLn 1, Col 1Go

copy

Gocopying-slices-safely.go

24 linesLn 1, Col 1Go

Always `make` the destination slice with the right length before calling `copy`. `copy` does not extend the destination — it only fills up to `len(dst)` elements.

Operation	Creates new array?	Independent?
Slice expression `s[a:b]`	No	No — shares underlying array
`copy(dst, src)`	No (dst must already exist)	Yes — independent after copy
`append` beyond capacity	Yes	Yes — new backing array allocated

Mark this lesson complete to store local progress and unlock a cleaner resume path the next time you visit.