Arrays and Slices

package main

import "fmt"

func main() {
	var empty [3]int                                 // zero value: every element is 0
	titles := [...]string{"Dune", "Emma", "Ulysses"} // the compiler counts the elements
	sparse := [5]int{1: 10, 3: 30}                   // indexed elements; the rest are zero
	sized := [...]string{2: "third", 0: "first"}     // length is the highest index + 1

	fmt.Println(empty, len(empty))
	fmt.Println(titles, len(titles), cap(titles))
	fmt.Println(sparse)
	fmt.Println(sized, len(sized))

	fmt.Printf("%T %T\n", empty, sparse) // [3]int and [5]int are different types
	fmt.Println(titles == [3]string{"Dune", "Emma", "Ulysses"})

	const n = len(titles) // len of an array is a constant (no function calls or receives in the expression)
	var copyOf [n]string
	copyOf = titles // assignment copies all elements
	copyOf[0] = "Changed"
	fmt.Println(titles[0], copyOf[0])
}

[0 0 0] 3
[Dune Emma Ulysses] 3 3
[0 10 0 30 0]
[first  third] 3
[3]int [5]int
true
Dune Changed

package main

import (
	"fmt"
	"unsafe"
)

func main() {
	backing := [6]int{10, 20, 30, 40, 50, 60}
	s := backing[1:4] // pointer to backing[1], length 3, capacity 5
	fmt.Println(s, len(s), cap(s))
	fmt.Println(unsafe.SliceData(s) == &backing[1])
	fmt.Println("header size in bytes:", unsafe.Sizeof(s)) // pointer + len + cap on a 64-bit platform

	s[0] = 99 // writes through to the shared array
	fmt.Println(backing)

	t := s[:cap(s)] // reslicing may extend up to the capacity
	fmt.Println(t, len(t))

	u := s[2:] // new header: pointer moves, len and cap shrink
	fmt.Println(u, len(u), cap(u))

	// Assigning a slice copies the header, not the elements.
	v := s
	v[1] = -1
	fmt.Println(s, v)
}

[20 30 40] 3 5
true
header size in bytes: 24
[10 99 30 40 50 60]
[99 30 40 50 60] 5
[40] 1 3
[99 -1 40] [99 -1 40]

package main

func main() {
	s := []int{1, 2}
	append(s, 3)
}

./main.go:5:2: append(s, 3) (value of type []int) is not used

main.go:7:6: append with no values

package main

import "fmt"

type Book struct {
	Title string
	Tags  []string
}

func main() {
	src := []int{1, 2, 3, 4, 5}
	dst := make([]int, 3)
	n := copy(dst, src) // copies min(len(dst), len(src)) elements
	fmt.Println(n, dst)

	dst2 := []int{} // length 0: copies nothing
	fmt.Println(copy(dst2, src), dst2)

	// Overlapping copy within one slice works like memmove.
	shift := []int{1, 2, 3, 4, 5}
	copy(shift[1:], shift)
	fmt.Println(shift)

	// Special case: copy from a string into []byte
	b := make([]byte, 4)
	copy(b, "Dune and more")
	fmt.Println(string(b))

	// copy is shallow: the elements are copied, anything they reference is shared.
	books := []Book{{"Dune", []string{"sf"}}}
	cp := make([]Book, len(books))
	copy(cp, books)
	cp[0].Title = "Changed"
	cp[0].Tags[0] = "classic" // the same array of tags
	fmt.Println(books, cp)
}

3 [1 2 3]
0 []
[1 1 2 3 4]
Dune
[{Dune [classic]}] [{Changed [classic]}]

package main

import "fmt"

func main() {
	arr := [6]int{0, 1, 2, 3, 4, 5}

	s := arr[1:3]   // len 2, cap 5
	t := arr[1:3:3] // full slice expression: len 2, cap 2
	fmt.Println(s, len(s), cap(s))
	fmt.Println(t, len(t), cap(t))

	s = append(s, 100) // writes arr[3]
	fmt.Println(arr)

	t = append(t, 200) // capacity exhausted: copies to a new array, arr is untouched
	fmt.Println(arr, t)

	// Typical use: hand out a view that the callee cannot grow into your data.
	head := arr[:2:2]
	head = append(head, -1)
	fmt.Println(arr, head)

	// Full slice expressions also work on slices and need 0 <= low <= high <= max <= cap.
	sl := []int{1, 2, 3, 4, 5}
	fmt.Println(sl[1:2:4], cap(sl[1:2:4]))
}

[1 2] 2 5
[1 2] 2 2
[0 1 2 100 4 5]
[0 1 2 100 4 5] [1 2 200]
[0 1 2 100 4 5] [0 1 -1]
[2] 3

package main

import "fmt"

func main() {
	s := []int{1, 2, 3, 4}

	arr := [4]int(s) // Go 1.20: slice to array conversion copies the elements
	arr[0] = 99
	fmt.Println(s, arr)

	p := (*[4]int)(s) // Go 1.17: slice to array pointer shares the backing array
	p[1] = 77
	fmt.Println(s, *p)

	sub := [2]int(s[2:]) // the length must be at least the array length
	fmt.Println(sub)

	defer func() {
		fmt.Println("recovered:", recover())
	}()
	_ = [5]int(s)
}

[1 2 3 4] [99 2 3 4]
[1 77 3 4] [1 77 3 4]
[3 4]
recovered: runtime error: cannot convert slice with length 4 to array or pointer to array with length 5

package main

import "fmt"

type Book struct {
	Title string
	Pages int
}

func main() {
	nums := []int{1, 2, 3}
	clear(nums) // zeroes every element, keeps the length
	fmt.Println(nums, len(nums))

	ptrs := []*Book{{"Dune", 612}, {"Emma", 474}}
	clear(ptrs[1:]) // lets the garbage collector reclaim the second *Book
	fmt.Println(ptrs[0].Title, ptrs[1] == nil)

	m := map[string]int{"a": 1}
	clear(m) // for maps it deletes every entry
	fmt.Println(len(m))
}

[0 0 0] 3
Dune true
0

package main

import (
	"cmp"
	"fmt"
	"slices"
	"strings"
)

type Book struct {
	Title  string
	Author string
	Year   int
}

func main() {
	nums := []int{5, 2, 8, 2, 9, 1}

	cp := slices.Clone(nums) // new backing array; Clone(nil) stays nil
	slices.Sort(cp)
	fmt.Println(nums, cp)

	fmt.Println(slices.Contains(nums, 8), slices.Index(nums, 2), slices.Index(nums, 42))
	fmt.Println(slices.Max(nums), slices.Min(nums))

	i, found := slices.BinarySearch(cp, 8)
	fmt.Println(i, found)

	cp = slices.Compact(cp) // removes consecutive duplicates (sort first)
	fmt.Println(cp)

	cp = slices.Insert(cp, 1, 100, 101) // insert at index 1
	fmt.Println(cp)
	cp = slices.Delete(cp, 1, 3) // delete [1:3)
	fmt.Println(cp)

	fmt.Println(slices.Concat([]int{1}, []int{2, 3}, nil, []int{4}))
	fmt.Println(slices.Repeat([]string{"ab"}, 3))

	g := slices.Grow([]int{1}, 100) // guarantees room for 100 more appends
	fmt.Println(len(g), cap(g) >= 101)

	slices.Reverse(nums)
	fmt.Println(nums, slices.Equal(nums, []int{1, 9, 2, 8, 2, 5}))

	books := []Book{
		{"Emma", "Austen", 1815},
		{"Dune", "Herbert", 1965},
		{"Persuasion", "Austen", 1817},
	}
	slices.SortFunc(books, func(a, b Book) int {
		return cmp.Or(
			strings.Compare(a.Author, b.Author),
			cmp.Compare(a.Year, b.Year),
		)
	})
	fmt.Println(books)

	idx, ok := slices.BinarySearchFunc(books, "Herbert", func(b Book, name string) int {
		return strings.Compare(b.Author, name)
	})
	fmt.Println(idx, ok)

	j := slices.IndexFunc(books, func(b Book) bool { return b.Year > 1900 })
	fmt.Println(j, slices.ContainsFunc(books, func(b Book) bool { return b.Title == "Nope" }))

	books = slices.DeleteFunc(books, func(b Book) bool { return b.Author == "Austen" })
	fmt.Println(books)

	for c := range slices.Chunk([]int{1, 2, 3, 4, 5}, 2) {
		fmt.Print(c, " ")
	}
	fmt.Println()
	fmt.Println(slices.Collect(slices.Values([]int{7, 8})), slices.Sorted(slices.Values([]int{3, 1, 2})))
}

[5 2 8 2 9 1] [1 2 2 5 8 9]
true 1 -1
9 1
4 true
[1 2 5 8 9]
[1 100 101 2 5 8 9]
[1 2 5 8 9]
[1 2 3 4]
[ab ab ab]
1 true
[1 9 2 8 2 5] true
[{Emma Austen 1815} {Persuasion Austen 1817} {Dune Herbert 1965}]
2 true
2 false
[{Dune Herbert 1965}]
[1 2] [3 4] [5]
[7 8] [1 2 3]

package main

import (
	"fmt"
	"slices"
)

type Loan struct{ ID int }

func main() {
	loans := []*Loan{{1}, {2}, {3}, {4}}

	// Older idiom: the tail element still points at a Loan, so it stays reachable.
	old := slices.Clone(loans)
	old = append(old[:1], old[2:]...)
	fmt.Println(len(old), cap(old), old[:cap(old)][3] != nil)

	// slices.Delete zeroes the vacated tail elements (Go 1.22).
	loans = slices.Delete(loans, 1, 2)
	fmt.Println(len(loans), cap(loans), loans[:cap(loans)][3] == nil)

	// Retaining a tiny sub-slice keeps the whole backing array alive.
	big := make([]byte, 1<<20)
	big[0] = 'X'
	head := big[:4]                // len 4 but pins 1 MiB
	copyHead := slices.Clone(head) // cap is small; big can be collected
	fmt.Println(len(head), cap(head), len(copyHead), cap(copyHead))
}

3 4 true
3 4 true
4 1048576 4 8

package main

import "fmt"

func main() {
	s := []int{1, 2, 3}
	defer func() { fmt.Println("recovered:", recover()) }()
	for i := 0; i <= 3; i++ {
		fmt.Println(s[i])
	}
}

1
2
3
recovered: runtime error: index out of range [3] with length 3