Для сортировки слайсов (срезов) в Go используйте slices.Sort для чисел и строк, slices.SortFunc для собственного правила сравнения. Если элементы с одинаковым ключом должны сохранить исходный порядок, нужна slices.SortStableFunc. Все три функции меняют переданный слайс.
Пакеты slices и cmp входят в стандартную библиотеку с Go 1.21. Ниже разберём сортировку по возрастанию и убыванию, несколько полей структуры и случаи, когда стабильность влияет на результат.
Как выбрать функцию сортировки
| Задача | Функция | Что задаёт порядок |
|---|---|---|
| Числа или строки по возрастанию | slices.Sort | Порядок значений типа |
| Структуры по полю, числа по убыванию | slices.SortFunc | Функция сравнения |
| Сохранить порядок элементов с равными ключами | slices.SortStableFunc | Функция сравнения и исходная последовательность |
Sort и SortFunc не гарантируют сохранение порядка равных элементов. Для слайса целых чисел это обычно несущественно: две одинаковые двойки неразличимы. Для заявок с одинаковым приоритетом исходный порядок может определять очередь обработки.
slices.Sort: числа и строки по возрастанию
Полная программа:
package main
import (
"fmt"
"slices"
)
func main() {
numbers := []int{8, 2, 5, 2}
slices.Sort(numbers)
fmt.Println(numbers) // [2 2 5 8]
names := []string{"bob", "alice", "anna"}
slices.Sort(names)
fmt.Println(names) // [alice anna bob]
}
У slices.Sort нет возвращаемого значения. Запись numbers = slices.Sort(numbers) не скомпилируется.
Функция принимает слайсы типов из ограничения cmp.Ordered: целые числа, числа с плавающей точкой и строки. Подходят и собственные типы с такой основой, например type Score int. Для []bool или []User нужно явно задать сравнение через SortFunc.
Строки сравниваются лексикографически по байтам. Это не сортировка по правилам русского языка. Регистр, положение ё и другие языковые особенности требуют отдельного правила сравнения.
Как сохранить исходный слайс
Далее в коротких фрагментах опущены package main, импорты и функция main. Вызовы размещайте внутри main, объявления типов на уровне пакета. Нужные импорты указаны рядом с каждым фрагментом.
Чтобы сохранить исходный порядок, сначала создайте копию через slices.Clone. Для примера нужны fmt и slices:
original := []int{8, 2, 5}
sorted := slices.Clone(original)
slices.Sort(sorted)
fmt.Println(original) // [8 2 5]
fmt.Println(sorted) // [2 5 8]
Присваивание sorted := original копирует только описание слайса. Оба значения будут обращаться к одному базовому массиву, поэтому сортировку увидит и original. То же относится к сортировке части слайса: slices.Sort(original[1:]) переставит элементы в соответствующей части общего массива.
slices.Clone копирует элементы присваиванием. Для []*User копируются указатели, сами пользователи остаются общими. Этого достаточно, чтобы независимо менять порядок указателей. Для независимого изменения полей пользователей нужна отдельная копия объектов.
slices.SortFunc: сравнение и порядок по убыванию
Функция сравнения, или компаратор, принимает два элемента и возвращает int. Сортировка учитывает знак результата:
Результат compare(a, b) | Положение элементов |
|---|---|
| Отрицательный | a должен быть раньше b |
| Ноль | Элементы равны по выбранному правилу |
| Положительный | a должен быть позже b |
Для чисел и строк используйте cmp.Compare. Чтобы получить убывающий порядок, поменяйте аргументы местами:
numbers := []int{8, 2, 5, 2}
slices.SortFunc(numbers, func(a, b int) int {
return cmp.Compare(b, a)
})
fmt.Println(numbers) // [8 5 2 2]
Здесь нужны импорты cmp, fmt и slices. Вызов cmp.Compare(a, b) дал бы возрастающий порядок.
Почему нельзя просто вернуть a - b
Вычитание выглядит как короткая замена cmp.Compare, но на границах целочисленного типа оно переполняется. Знак результата перестаёт отражать отношение чисел:
maxInt := int(^uint(0) >> 1)
a, b := maxInt, -1
fmt.Println(a > b) // true
fmt.Println(a-b < 0) // true: результат переполнился
fmt.Println(cmp.Compare(a, b) > 0) // true: сравнение корректно
Для фрагмента нужны cmp и fmt. Ошибка возникает даже при сравнении двух значений, до вызова сортировки. Для полей типа uint вычитание тоже не подходит: результат не может быть отрицательным. Преобразование к int не исправляет сравнение для всего диапазона значений.
Как отсортировать слайс структур по полю
Отсортируем пользователей по возрасту:
package main
import (
"cmp"
"fmt"
"slices"
)
type User struct {
ID int
Name string
Age int
}
func main() {
users := []User{
{ID: 3, Name: "Борис", Age: 30},
{ID: 1, Name: "Анна", Age: 25},
{ID: 2, Name: "Вера", Age: 20},
}
slices.SortFunc(users, func(a, b User) int {
return cmp.Compare(a.Age, b.Age)
})
for _, u := range users {
fmt.Println(u.Name, u.Age)
}
// Вера 20
// Анна 25
// Борис 30
}
Компаратор получает значения User, а не индексы. Если возраст совпадает, он вернёт 0, даже когда имена и идентификаторы различаются. Равенство для сортировки определяется только этим правилом.
Если порядок таких пользователей несущественен, достаточно SortFunc. Если нужен порядок поступления, используйте стабильную сортировку. Для воспроизводимого результата независимо от исходной последовательности добавьте второй ключ.
Сортировка по нескольким полям
Пусть пользователи должны идти по возрасту, затем по имени. При совпадении обоих полей сравним идентификаторы. Возьмём записи, в которых каждый из этих ключей влияет на результат:
users := []User{
{ID: 4, Name: "Борис", Age: 30},
{ID: 3, Name: "Анна", Age: 25},
{ID: 2, Name: "Анна", Age: 25},
{ID: 1, Name: "Вера", Age: 25},
}
slices.SortFunc(users, func(a, b User) int {
if c := cmp.Compare(a.Age, b.Age); c != 0 {
return c
}
if c := cmp.Compare(a.Name, b.Name); c != 0 {
return c
}
return cmp.Compare(a.ID, b.ID)
})
for _, u := range users {
fmt.Println(u.ID, u.Name, u.Age)
}
// 2 Анна 25
// 3 Анна 25
// 1 Вера 25
// 4 Борис 30
Фрагмент использует тип User из предыдущего примера и импорты cmp, fmt, slices. Следующее поле участвует в сравнении, только если предыдущие равны. Две Анны одного возраста идут по ID. При уникальном ID две разные записи уже не будут равны по компаратору.
Направление можно выбирать отдельно для каждого поля. Например, cmp.Compare(b.Age, a.Age) поставит старших первыми, а сравнение имён оставит по возрастанию.
Не заменяйте такое сравнение двумя вызовами обычной сортировки. После сортировки по имени вызов SortFunc по возрасту не обязан сохранять порядок имён внутри возрастной группы. Если нужны отдельные проходы, сначала сортируйте по второстепенному ключу, затем стабильно по главному.
Стабильность не гарантирует одинаковый результат после обхода map
Порядок обхода map не определён. Если собрать пользователей из map и стабильно отсортировать только по возрасту, внутри одной возрастной группы сохранится порядок этого обхода. Между запусками он может различаться.
Если тест сравнивает выгрузки из map, добавьте уникальный ключ, как ID в примере выше. Тогда порядок одинакового набора записей будет зависеть от значений полей, а не от последовательности обхода. О сборе ключей и значений читайте в статье про map в Go.
slices.SortStableFunc: что означает стабильность
Стабильная сортировка сохраняет взаимный порядок элементов, для которых компаратор возвращает 0. Сами структуры могут при этом различаться во всех остальных полях.
Возьмём заявки в порядке поступления. Меньшее число означает более высокий приоритет. Среди заявок одного приоритета первой должна остаться та, которая поступила раньше:
package main
import (
"cmp"
"fmt"
"slices"
)
type Task struct {
ID string
Priority int
}
func main() {
tasks := []Task{
{ID: "C", Priority: 2},
{ID: "D", Priority: 1},
{ID: "A", Priority: 2},
{ID: "B", Priority: 1},
}
slices.SortStableFunc(tasks, func(a, b Task) int {
return cmp.Compare(a.Priority, b.Priority)
})
fmt.Println(tasks) // [{D 1} {B 1} {C 2} {A 2}]
}
D остаётся перед B, а C перед A. Это гарантия SortStableFunc. Обычная сортировка на этих четырёх элементах может выдать тот же результат. Такой запуск не доказывает стабильность: для SortFunc сохранение порядка не обещано.
В стабильном варианте D остаётся перед B, потому что поступила раньше. При сравнении по второму ключу ID заявка B обгоняет D. Если нужна очередь поступления внутри каждого приоритета, выбирайте SortStableFunc без дополнительного ключа.
Какие требования есть к компаратору
SortFunc и SortStableFunc требуют строгого слабого порядка. Для обычного сравнения по полям это означает следующее:
- Сравнение элемента с самим собой возвращает
0. - Если
aидёт раньшеb, тоbидёт позжеa. - Если
aраньшеb, аbраньшеc, тоaраньшеc. - Равенство по компаратору тоже согласовано: если
aравноb, аbравноc, тоaравноc.
Например, компаратор «при a <= b вернуть -1, иначе 1» неверен. Он считает элемент меньшим самого себя. Функция на основе случайного числа или меняющихся во время сортировки полей тоже не задаёт согласованный порядок.
Компаратор должен сравнивать элементы, не изменяя их и слайс. Не рассчитывайте на определённое число вызовов или последовательность пар. При нарушении контракта полагаться на результат сортировки нельзя.
Числа с плавающей точкой и NaN
Для float64 простое сравнение через < и > требует внимания к NaN. Оба выражения ложны, если один из операндов NaN. Компаратор, который после двух таких проверок возвращает 0, объявит NaN равным любому числу. Это нарушит согласованность равенства: 1 окажется равна NaN, NaN равна 2, а 1 и 2 различаются.
slices.Sort уже учитывает этот случай. Все NaN располагаются перед остальными значениями:
values := []float64{3, math.NaN(), -1, 2}
slices.Sort(values)
fmt.Println(values) // [NaN -1 2 3]
Для примера нужны fmt, math и slices. Если пишете свой компаратор для числового поля, используйте cmp.Compare: он считает NaN меньше любого обычного числа, а два NaN равными для сравнения. При перестановке аргументов для убывания NaN окажутся в конце.
Когда использовать пакет sort
Если проект должен собираться на Go 1.20, используйте sort.Slice для собственного сравнения и sort.SliceStable для стабильной сортировки. Пакета slices в стандартной библиотеке этой версии ещё нет.
У sort.Slice другой компаратор: он получает индексы и возвращает bool со значением «первый элемент меньше второго»:
sort.Slice(users, func(i, j int) bool {
return users[i].Age < users[j].Age
})
Нужен импорт sort; users взят из примера со структурами. Для стабильного варианта замените имя функции на sort.SliceStable. Условие должно оставаться строгим: <, а не <=.
Для нового кода на Go 1.21 и новее начинайте с slices: компаратор принимает элементы нужного типа, и ему не приходится обращаться к внешнему слайсу по индексам. Пакет sort также нужен, когда данные представлены через sort.Interface, а не готовым слайсом.
Частые вопросы
Можно ли сортировать nil и пустой слайс?
nil использовать не следует.Чем slices.Sort отличается от slices.Sorted?
Sort меняет переданный слайс и ничего не возвращает. Функция Sorted появилась в Go 1.23: она получает итератор iter.Seq, собирает значения в новый слайс, сортирует его и возвращает результат. Для сортировки копии существующего слайса на Go 1.21 достаточно slices.Clone и slices.Sort.Можно ли отсортировать слайс указателей на структуры?
SortFunc или SortStableFunc. Для []*User компаратор принимает a, b *User и может сравнивать a.Age и b.Age. Если слайс содержит nil, сначала задайте его положение относительно непустых указателей. Прямое обращение к полю через nil вызовет панику.Сохранится ли стабильность, если отсортировать и вызвать slices.Reverse?
Reverse перевернёт весь слайс, включая порядок внутри групп с равными ключами. Если по условию нужен убывающий порядок с сохранением исходной последовательности равных элементов, сразу используйте SortStableFunc и поменяйте аргументы в cmp.Compare местами.Итог
Для чисел и строк по возрастанию используйте slices.Sort. Когда порядок задаётся полями структуры или нужен порядок по убыванию, передайте компаратор в slices.SortFunc. Сравнивайте числа через cmp.Compare, чтобы не получить переполнение при вычитании.
Если равные по выбранным полям элементы должны сохранить исходную последовательность, вызывайте slices.SortStableFunc. Для воспроизводимого результата после обхода map задайте дополнительные ключи. Перед любой сортировкой сделайте копию через slices.Clone, если исходный порядок нужен дальше.
Теги: