Golang Sort Slice: slices.Sort, SortFunc and Multiple Fields

Sorting built-in types

slices.Sort sorts any slice whose element type is ordered: integers, floats and strings. It sorts in place and returns nothing.

package main

import (
	"fmt"
	"slices"
)

func main() {
	nums := []int{42, 7, 19, 3, 88}
	slices.Sort(nums)
	fmt.Println(nums)

	names := []string{"lisa", "Bob", "alice", "Carl"}
	slices.Sort(names)
	fmt.Println(names) // byte order: uppercase before lowercase

	fmt.Println(slices.IsSorted(nums))

	i, found := slices.BinarySearch(nums, 19)
	fmt.Println(i, found)
}

Output:

[3 7 19 42 88]
[Bob Carl alice lisa]
true
2 true

Strings sort by bytes, so every uppercase ASCII letter comes before every lowercase one. That is rarely what a user expects for names. The next section fixes it.

The slices package arrived in Go 1.21. Its Sort is a pattern-defeating quicksort: O(n log n), in place, and not stable.

Custom order with SortFunc

slices.SortFunc takes a comparison function func(a, b T) int. Return a negative number when a should come first, a positive number when b should, and zero when they are equal. The cmp.Compare helper returns exactly that for ordered types.

package main

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

func main() {
	names := []string{"lisa", "Bob", "alice", "Carl"}
	slices.SortFunc(names, func(a, b string) int {
		return cmp.Compare(strings.ToLower(a), strings.ToLower(b))
	})
	fmt.Println(names)

	// Descending: swap a and b.
	nums := []int{42, 7, 19, 3, 88}
	slices.SortFunc(nums, func(a, b int) int {
		return cmp.Compare(b, a)
	})
	fmt.Println(nums)

	// By length, shortest first.
	words := []string{"banana", "fig", "apple", "kiwi"}
	slices.SortFunc(words, func(a, b string) int {
		return cmp.Compare(len(a), len(b))
	})
	fmt.Println(words)
}

strings.ToLower inside a comparison allocates a new string whenever its input has an uppercase letter, and the comparison runs about n log n times. For big slices, compute the lowercase keys once. For names in other languages (accents, locale rules), use golang.org/x/text/collate, which is outside the standard library.

A comparison function must be consistent: if it says a comes before b, it must say b comes after a. One that breaks this (for example, returning -1 whenever two values differ) produces a wrongly ordered slice with no error. Subtracting integers (return a - b) looks neat but overflows for large values; use cmp.Compare.

Sorting structs

The comparison function receives elements, so sorting structs by a field is the same call:

package main

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

type Employee struct {
	Name   string
	Dept   string
	Salary int
}

func main() {
	staff := []Employee{
		{"Ana", "eng", 120},
		{"Bob", "sales", 90},
		{"Cy", "eng", 150},
		{"Dee", "sales", 90},
		{"Eve", "eng", 120},
	}

	slices.SortFunc(staff, func(a, b Employee) int {
		return cmp.Compare(a.Salary, b.Salary)
	})
	for _, e := range staff {
		fmt.Println(e.Salary, e.Name)
	}
}

Employees with equal salaries may come out in any order here, because SortFunc is not stable. If you need a guaranteed order, either break ties with more fields or use a stable sort.

Sorting by multiple fields

Compare the most important field first and move to the next only on a tie. cmp.Or (Go 1.22) returns its first non-zero argument, which turns this into one line:

package main

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

type Employee struct {
	Name   string
	Dept   string
	Salary int
}

func main() {
	staff := []Employee{
		{"Ana", "eng", 120},
		{"Bob", "sales", 90},
		{"Cy", "eng", 150},
		{"Dee", "sales", 90},
		{"Eve", "eng", 120},
	}

	// Department A to Z, then salary high to low, then name A to Z.
	slices.SortFunc(staff, func(a, b Employee) int {
		return cmp.Or(
			cmp.Compare(a.Dept, b.Dept),
			cmp.Compare(b.Salary, a.Salary),
			cmp.Compare(a.Name, b.Name),
		)
	})
	for _, e := range staff {
		fmt.Printf("%-6s %4d %s\n", e.Dept, e.Salary, e.Name)
	}
}

Output:

eng     150 Cy
eng     120 Ana
eng     120 Eve
sales    90 Bob
sales    90 Dee

Every comparison is evaluated even when the first one decides, since they are plain arguments. That costs little for field comparisons. When a tie-breaker is expensive, write the if c := ...; c != 0 { return c } chain by hand.

Stable sort

A stable sort keeps elements that compare equal in their original order. That matters when the input already has a meaningful order, for example records sorted by time that you now group by user.

package main

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

type Event struct {
	User string
	Seq  int
}

func main() {
	events := []Event{
		{"bob", 1}, {"ana", 2}, {"bob", 3}, {"ana", 4}, {"bob", 5},
	}
	slices.SortStableFunc(events, func(a, b Event) int {
		return cmp.Compare(a.User, b.User)
	})
	fmt.Println(events)
}

This prints [{ana 2} {ana 4} {bob 1} {bob 3} {bob 5}]: within each user, the original sequence survives. Stable sorting does more work, so use it only when the order of equal elements matters.

Sorting a map

Maps have no order. To show a map sorted by key, sort its keys: slices.Sorted(maps.Keys(m)) (Go 1.23). To sort by value, sort the keys with a comparison that looks up the values:

package main

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

func main() {
	wordCount := map[string]int{"go": 12, "map": 3, "slice": 7, "chan": 7}

	keys := slices.Collect(maps.Keys(wordCount))
	slices.SortFunc(keys, func(a, b string) int {
		return cmp.Or(
			cmp.Compare(wordCount[b], wordCount[a]), // count, high first
			cmp.Compare(a, b),                       // then word, for a stable result
		)
	})
	for _, k := range keys {
		fmt.Println(k, wordCount[k])
	}
}

The tie-breaker on the word matters: without it, chan and slice (both 7) would print in a different order from run to run, because the keys come out of the map in random order. See maps for more.

The sort package: sort.Slice and friends

Before Go 1.21, sorting went through the sort package. You will see it in a lot of existing code:

sort.Ints(nums)
sort.Strings(names)
sort.Slice(staff, func(i, j int) bool {
	return staff[i].Salary < staff[j].Salary
})
sort.SliceStable(staff, func(i, j int) bool { ... })

Differences worth knowing:

A common sort.Slice bug is closing over a different slice than the one being sorted, since the less function indexes by position. SortFunc cannot have that bug because it hands you the elements.

The sort.Interface type (Len, Less, Swap) is the oldest form. It is still the way to sort data that is not a single slice, such as two parallel slices that must move together. Since Go 1.22, sort.Ints, sort.Strings and sort.Float64s simply call slices.Sort.

Common mistakes

• Expecting Sort to return the sorted slice. It sorts in place and returns nothing. Use slices.Sorted(slices.Values(s)) if you want a new sorted slice, or slices.Clone first.
• Assuming equal elements keep their order. Only the Stable variants promise that.
• Subtracting to compare. a - b overflows. Use cmp.Compare.
• Sorting floats with NaN. cmp.Compare orders NaN before every other value, which keeps the sort consistent. A hand-written a < b comparison does not.