The slices package: sort, search and compare

Six exam results ordered by marks, highest first, with tied marks in name order, take one call in Go: slices.SortFunc with a comparison built from cmp.Compare and cmp.Or. The slices package, part of the standard library since Go 1.21, also searches sorted data, edits slices in place and compares them, with generic functions that the compiler checks for each element type.

You will sort numbers and strings, write comparisons on several keys, find values with a binary search and insert new ones where they belong. Each output below is the one its program printed when it ran with Go 1.27.1.

slices.Sort puts numbers and strings in order, strings by their bytes

slices.Sort sorts any slice whose elements are ordered, integers, floats or strings, in place and from the smallest:

// sort_basics.go: slices.Sort on numbers and strings, and strings ordered by their bytes.
package main

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

func main() {
	marks := []int{67, 91, 42, 88, 58}
	slices.Sort(marks) // in place, smallest first
	fmt.Println(marks, slices.IsSorted(marks))

	names := []string{"arjun", "Zoya", "Meera", "bala"}
	slices.Sort(names) // byte by byte: 'M' (77) and 'Z' (90) come before 'a' (97)
	fmt.Println(names)

	slices.SortFunc(names, func(a, b string) int {
		return strings.Compare(strings.ToLower(a), strings.ToLower(b))
	})
	fmt.Println(names)
	fmt.Println(slices.Min(marks), slices.Max(marks), slices.Index(marks, 88))
}

[42 58 67 88 91] true
[Meera Zoya arjun bala]
[arjun bala Meera Zoya]
42 91 3

The marks came out as expected, and slices.IsSorted confirmed it. The names did not: [Meera Zoya arjun bala]. Strings compare byte by byte, and in ASCII every capital letter, 65 to 90, comes before every small letter, 97 to 122, so both capitalised names sorted first. A comparison functioncomparison function: A function of two elements, a and b, that returns a negative number when a sorts first, a positive one when b does, and 0 when they tie, as slices.SortFunc expects. passed to slices.SortFunc can compare something else instead, here the names in lower case, which gave [arjun bala Meera Zoya]. The last line shows three more functions that read a slice: slices.Min, slices.Max and slices.Index, which returned 3, the position of 88 after the sort.

A comparison returns a sign, and cmp.Or chains the keys

slices.SortFunc calls its function with two elements, a and b, and reads only the sign of the result: negative puts a first, positive puts b first, and zero means they tie. cmp.Compare(x, y) returns -1, 0 or +1, so it supplies the sign for one key, and cmp.Or returns the first of its arguments that is not zero, which chains keys:

// leaderboard.go: marks highest first, then names A to Z where marks tie, with cmp.Compare and cmp.Or.
package main

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

type Result struct {
	Name  string
	Marks int
}

func main() {
	results := []Result{
		{"Ravi", 88}, {"Asha", 91}, {"Kiran", 88},
		{"Meera", 75}, {"Dev", 91}, {"Bala", 88},
	}
	slices.SortFunc(results, func(a, b Result) int {
		return cmp.Or(
			cmp.Compare(b.Marks, a.Marks), // b before a: highest marks first
			cmp.Compare(a.Name, b.Name),   // then names in order
		)
	})
	for i, r := range results {
		fmt.Printf("%d. %-5s %d\n", i+1, r.Name, r.Marks)
	}
	fmt.Println(cmp.Compare(88, 91), cmp.Compare(91, 91), cmp.Compare("Ravi", "Kiran"))
}

1. Asha  91
2. Dev   91
3. Bala  88
4. Kiran 88
5. Ravi  88
6. Meera 75
-1 0 1

Swapping the arguments, cmp.Compare(b.Marks, a.Marks), turned the order round, so the marks ran from 91 down. The three rows with 88 tied on marks, and the names settled them. Follow the function through two of its calls:

Both comparisons are evaluated before cmp.Or runs, because they are its arguments, so a key that is costly to compute belongs in an if that returns early instead. The package’s documentation adds one requirement, a strict weak ordering: the same pair must always get the same answer, and if a comes before b and b before c, a must come before c, or the sort may come out wrong.

BinarySearch finds a value, or the place where it belongs

A binary searchbinary search: A search of sorted data that looks at the middle element and drops the half that cannot hold the target, so n values need at most about log2 n looks. looks at the middle of a sorted slice and throws away the half that cannot hold the target, so 9 marks need at most 4 looks. Step through a search for 73 in these marks:

The figure found 73 at index 5 with three probes. slices.BinarySearch halves the range in the same way, but it keeps going until it reaches the first position whose value is not below the target. That is why it can answer for a value that is missing as well:

// binsearch.go: BinarySearch on sorted marks, for a value that is there and one that is not.
package main

import (
	"fmt"
	"slices"
)

func main() {
	marks := []int{35, 42, 58, 61, 67, 73, 88, 91, 95}

	i, found := slices.BinarySearch(marks, 73)
	fmt.Println(i, found) // where 73 is

	i, found = slices.BinarySearch(marks, 70)
	fmt.Println(i, found) // where 70 would go

	marks = slices.Insert(marks, i, 70) // inserting there keeps the slice sorted
	fmt.Println(marks, slices.IsSorted(marks))
}

5 true
5 false
[35 42 58 61 67 70 73 88 91 95] true

For 73 it returned 5 true; for 70, 5 false: 70 is not there, and index 5 is where it would go. slices.Insert at that index kept the slice sorted. The search trusts its input, though: on a slice that is not sorted it returns wrong answers without any error.

The package has more: slices.SortStableFunc is a stable sortstable sort: A sort that keeps equal elements in the order they had before it ran, such as slices.SortStableFunc. slices.SortFunc does not promise to., which keeps equal elements in the order they had, as slices.SortFunc does not promise to. slices.Delete removes a range of elements in place. slices.Compact removes repeated values that sit next to each other. slices.Replace puts new elements in place of a range. slices.Equal reports whether two slices hold the same elements in the same order. The older sort package sorts through an interface or a function that compares two indexes.

Stable sorts, comparisons that break, and the sort package, measured Pro: opens with a Pro, Premium or Ultimate pass

Delete, Compact, Insert and Equal: what each does to the backing array Pro: opens with a Pro, Premium or Ultimate pass

Practise

Practice covers sorting by bytes, comparisons on several keys and binary search, starting with the idea your earlier answers left weakest. Each choice explains why it is right or what it misses:

Interview questions

Warm-up (fresher): Why does slices.Sort put “Zoya” before “arjun”?

Strings compare byte by byte, and the byte of a capital letter is smaller than that of any small letter: “Z” is 90 and “a” is 97. So every name that starts with a capital comes first. For an order that ignores case, sort with slices.SortFunc and compare lower-case forms of the names.

Three longer questions of the module bank build on this lesson:

Key takeaways

• slices.Sort sorts any ordered type in place, and strings sort by their bytes, so capitals come before small letters.
• A comparison returns a sign; cmp.Compare gives it for one key, swapping its arguments reverses the order, and cmp.Or chains keys by returning the first result that is not zero.
• slices.BinarySearch returns the position of the target, or where it belongs, and whether it was found; the slice must already be sorted.