Как проще всего отсортировать массив структур по произвольному полю в Go?

Проблема и её решение

Вы правы: стандартный подход с sort.Slice требует писать анонимную функцию для каждого поля. Однако в Go есть элегантный способ сделать сортировку универсальной — через замыкания и фабрику функций сравнения. Давайте разберём несколько подходов от простого к более продвинутому.

Способ 1: Фабрика компараторов (рекомендуемый)

Создайте функцию, которая возвращает нужную функцию сравнения в зависимости от имени поля:

package main

import (
    "fmt"
    "sort"
    "strings"
)

type User struct {
    Name  string
    Age   int
    Score float64
}

// byField возвращает функцию сравнения для sort.Slice по имени поля
func byField(users []User, field string) func(i, j int) bool {
    return func(i, j int) bool {
        switch field {
        case "Name":
            return strings.ToLower(users[i].Name) < strings.ToLower(users[j].Name)
        case "Age":
            return users[i].Age < users[j].Age
        case "Score":
            return users[i].Score < users[j].Score
        default:
            panic("неизвестное поле: " + field)
        }
    }
}

func main() {
    users := []User{
        {"Анна", 25, 88.5},
        {"Борис", 30, 92.1},
        {"Виктор", 22, 85.0},
    }

    // Сортировка по возрасту
    sort.Slice(users, byField(users, "Age"))
    fmt.Println("По возрасту:", users)

    // Сортировка по имени
    sort.Slice(users, byField(users, "Name"))
    fmt.Println("По имени:", users)

    // Сортировка по баллам
    sort.Slice(users, byField(users, "Score"))
    fmt.Println("По баллам:", users)
}

Способ 2: Использование рефлексии (для динамических полей)

Если поле выбирается во время выполнения и заранее неизвестно, можно использовать пакет reflect. Но помните: рефлексия медленнее и менее безопасна:

import (
    "reflect"
    "sort"
)

func sortByField(slice interface{}, fieldName string) {
    v := reflect.ValueOf(slice)
    if v.Kind() != reflect.Slice {
        panic("не слайс")
    }

    sort.SliceStable(slice, func(i, j int) bool {
        vi := v.Index(i).FieldByName(fieldName)
        vj := v.Index(j).FieldByName(fieldName)
        
        // Базовая поддержка строк и чисел
        switch vi.Kind() {
        case reflect.String:
            return vi.String() < vj.String()
        case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
            return vi.Int() < vj.Int()
        case reflect.Float32, reflect.Float64:
            return vi.Float() < vj.Float()
        default:
            panic("неподдерживаемый тип поля")
        }
    })
}

// Использование:
// sortByField(&users, "Age")
// sortByField(&users, "Name")

Способ 3: Сортировка по нескольким полям (композитная)

Часто нужно сортировать сначала по одному полю, а при равенстве — по другому. Вот пример для нашего User:

// Сортировка: сначала по возрасту, потом по имени
sort.Slice(users, func(i, j int) bool {
    if users[i].Age != users[j].Age {
        return users[i].Age < users[j].Age
    }
    return strings.ToLower(users[i].Name) < strings.ToLower(users[j].Name)
})

Можно обобщить и это:

func byFields(users []User, fields ...string) func(i, j int) bool {
    return func(i, j int) bool {
        for _, field := range fields {
            var less bool
            switch field {
            case "Name":
                less = strings.ToLower(users[i].Name) < strings.ToLower(users[j].Name)
            case "Age":
                less = users[i].Age < users[j].Age
            case "Score":
                less = users[i].Score < users[j].Score
            }
            if less {
                return true
            }
            // Проверяем, равны ли поля
            var equal bool
            switch field {
            case "Name":
                equal = strings.ToLower(users[i].Name) == strings.ToLower(users[j].Name)
            case "Age":
                equal = users[i].Age == users[j].Age
            case "Score":
                equal = users[i].Score == users[j].Score
            }
            if !equal {
                return false
            }
        }
        return false
    }
}

// Использование: sort.Slice(users, byFields(users, "Age", "Name"))

Что выбрать?

• Для простых случаев — используйте фабрику byField (Способ 1). Это безопасно, читаемо и эффективно.
• Для динамических полей — рефлексия (Способ 2), но с осторожностью.
• Для сложной сортировки — композитная функция (Способ 3).

Главное преимущество этих подходов — вы пишете логику сравнения один раз для каждого поля, а затем просто вызываете сортировку по имени поля. Это максимально приближает Go к удобству Python, сохраняя при этом производительность и типобезопасность.

import (
    "fmt"
    "sort"
    "github.com/icza/sortutil"
)

type User struct {
    Name  string
    Age   int
    Score float64
}

func main() {
    users := []User{
        {"Анна", 25, 88.5},
        {"Борис", 30, 92.1},
        {"Виктор", 22, 85.0},
    }

    // Сортировка по полю "Age" (по возрастанию)
    sortutil.Sort(users, "Age")
    fmt.Println("По возрасту:", users)

    // Сортировка по полю "Name" (по убыванию)
    sortutil.Sort(users, "-Name")
    fmt.Println("По имени (убыв.):", users)

    // Сортировка по нескольким полям
    sortutil.Sort(users, "Age", "Name")
    fmt.Println("По возрасту и имени:", users)
}